package com.jiawa.wiki.domain;

import java.util.ArrayList;
import java.util.Date;
import java.util.List;

public class TestresultExample {
    protected String orderByClause;

    protected boolean distinct;

    protected List<Criteria> oredCriteria;

    public TestresultExample() {
        oredCriteria = new ArrayList<>();
    }

    public void setOrderByClause(String orderByClause) {
        this.orderByClause = orderByClause;
    }

    public String getOrderByClause() {
        return orderByClause;
    }

    public void setDistinct(boolean distinct) {
        this.distinct = distinct;
    }

    public boolean isDistinct() {
        return distinct;
    }

    public List<Criteria> getOredCriteria() {
        return oredCriteria;
    }

    public void or(Criteria criteria) {
        oredCriteria.add(criteria);
    }

    public Criteria or() {
        Criteria criteria = createCriteriaInternal();
        oredCriteria.add(criteria);
        return criteria;
    }

    public Criteria createCriteria() {
        Criteria criteria = createCriteriaInternal();
        if (oredCriteria.size() == 0) {
            oredCriteria.add(criteria);
        }
        return criteria;
    }

    protected Criteria createCriteriaInternal() {
        Criteria criteria = new Criteria();
        return criteria;
    }

    public void clear() {
        oredCriteria.clear();
        orderByClause = null;
        distinct = false;
    }

    protected abstract static class GeneratedCriteria {
        protected List<Criterion> criteria;

        protected GeneratedCriteria() {
            super();
            criteria = new ArrayList<>();
        }

        public boolean isValid() {
            return criteria.size() > 0;
        }

        public List<Criterion> getAllCriteria() {
            return criteria;
        }

        public List<Criterion> getCriteria() {
            return criteria;
        }

        protected void addCriterion(String condition) {
            if (condition == null) {
                throw new RuntimeException("Value for condition cannot be null");
            }
            criteria.add(new Criterion(condition));
        }

        protected void addCriterion(String condition, Object value, String property) {
            if (value == null) {
                throw new RuntimeException("Value for " + property + " cannot be null");
            }
            criteria.add(new Criterion(condition, value));
        }

        protected void addCriterion(String condition, Object value1, Object value2, String property) {
            if (value1 == null || value2 == null) {
                throw new RuntimeException("Between values for " + property + " cannot be null");
            }
            criteria.add(new Criterion(condition, value1, value2));
        }

        public Criteria andIdIsNull() {
            addCriterion("ID is null");
            return (Criteria) this;
        }

        public Criteria andIdIsNotNull() {
            addCriterion("ID is not null");
            return (Criteria) this;
        }

        public Criteria andIdEqualTo(Double value) {
            addCriterion("ID =", value, "id");
            return (Criteria) this;
        }

        public Criteria andIdNotEqualTo(Double value) {
            addCriterion("ID <>", value, "id");
            return (Criteria) this;
        }

        public Criteria andIdGreaterThan(Double value) {
            addCriterion("ID >", value, "id");
            return (Criteria) this;
        }

        public Criteria andIdGreaterThanOrEqualTo(Double value) {
            addCriterion("ID >=", value, "id");
            return (Criteria) this;
        }

        public Criteria andIdLessThan(Double value) {
            addCriterion("ID <", value, "id");
            return (Criteria) this;
        }

        public Criteria andIdLessThanOrEqualTo(Double value) {
            addCriterion("ID <=", value, "id");
            return (Criteria) this;
        }

        public Criteria andIdIn(List<Double> values) {
            addCriterion("ID in", values, "id");
            return (Criteria) this;
        }

        public Criteria andIdNotIn(List<Double> values) {
            addCriterion("ID not in", values, "id");
            return (Criteria) this;
        }

        public Criteria andIdBetween(Double value1, Double value2) {
            addCriterion("ID between", value1, value2, "id");
            return (Criteria) this;
        }

        public Criteria andIdNotBetween(Double value1, Double value2) {
            addCriterion("ID not between", value1, value2, "id");
            return (Criteria) this;
        }

        public Criteria and序列号IsNull() {
            addCriterion("序列号 is null");
            return (Criteria) this;
        }

        public Criteria and序列号IsNotNull() {
            addCriterion("序列号 is not null");
            return (Criteria) this;
        }

        public Criteria and序列号EqualTo(String value) {
            addCriterion("序列号 =", value, "序列号");
            return (Criteria) this;
        }

        public Criteria and序列号NotEqualTo(String value) {
            addCriterion("序列号 <>", value, "序列号");
            return (Criteria) this;
        }

        public Criteria and序列号GreaterThan(String value) {
            addCriterion("序列号 >", value, "序列号");
            return (Criteria) this;
        }

        public Criteria and序列号GreaterThanOrEqualTo(String value) {
            addCriterion("序列号 >=", value, "序列号");
            return (Criteria) this;
        }

        public Criteria and序列号LessThan(String value) {
            addCriterion("序列号 <", value, "序列号");
            return (Criteria) this;
        }

        public Criteria and序列号LessThanOrEqualTo(String value) {
            addCriterion("序列号 <=", value, "序列号");
            return (Criteria) this;
        }

        public Criteria and序列号Like(String value) {
            addCriterion("序列号 like", value, "序列号");
            return (Criteria) this;
        }

        public Criteria and序列号NotLike(String value) {
            addCriterion("序列号 not like", value, "序列号");
            return (Criteria) this;
        }

        public Criteria and序列号In(List<String> values) {
            addCriterion("序列号 in", values, "序列号");
            return (Criteria) this;
        }

        public Criteria and序列号NotIn(List<String> values) {
            addCriterion("序列号 not in", values, "序列号");
            return (Criteria) this;
        }

        public Criteria and序列号Between(String value1, String value2) {
            addCriterion("序列号 between", value1, value2, "序列号");
            return (Criteria) this;
        }

        public Criteria and序列号NotBetween(String value1, String value2) {
            addCriterion("序列号 not between", value1, value2, "序列号");
            return (Criteria) this;
        }

        public Criteria and减速机型号IsNull() {
            addCriterion("减速机型号 is null");
            return (Criteria) this;
        }

        public Criteria and减速机型号IsNotNull() {
            addCriterion("减速机型号 is not null");
            return (Criteria) this;
        }

        public Criteria and减速机型号EqualTo(String value) {
            addCriterion("减速机型号 =", value, "减速机型号");
            return (Criteria) this;
        }

        public Criteria and减速机型号NotEqualTo(String value) {
            addCriterion("减速机型号 <>", value, "减速机型号");
            return (Criteria) this;
        }

        public Criteria and减速机型号GreaterThan(String value) {
            addCriterion("减速机型号 >", value, "减速机型号");
            return (Criteria) this;
        }

        public Criteria and减速机型号GreaterThanOrEqualTo(String value) {
            addCriterion("减速机型号 >=", value, "减速机型号");
            return (Criteria) this;
        }

        public Criteria and减速机型号LessThan(String value) {
            addCriterion("减速机型号 <", value, "减速机型号");
            return (Criteria) this;
        }

        public Criteria and减速机型号LessThanOrEqualTo(String value) {
            addCriterion("减速机型号 <=", value, "减速机型号");
            return (Criteria) this;
        }

        public Criteria and减速机型号Like(String value) {
            addCriterion("减速机型号 like", value, "减速机型号");
            return (Criteria) this;
        }

        public Criteria and减速机型号NotLike(String value) {
            addCriterion("减速机型号 not like", value, "减速机型号");
            return (Criteria) this;
        }

        public Criteria and减速机型号In(List<String> values) {
            addCriterion("减速机型号 in", values, "减速机型号");
            return (Criteria) this;
        }

        public Criteria and减速机型号NotIn(List<String> values) {
            addCriterion("减速机型号 not in", values, "减速机型号");
            return (Criteria) this;
        }

        public Criteria and减速机型号Between(String value1, String value2) {
            addCriterion("减速机型号 between", value1, value2, "减速机型号");
            return (Criteria) this;
        }

        public Criteria and减速机型号NotBetween(String value1, String value2) {
            addCriterion("减速机型号 not between", value1, value2, "减速机型号");
            return (Criteria) this;
        }

        public Criteria and工单号IsNull() {
            addCriterion("工单号 is null");
            return (Criteria) this;
        }

        public Criteria and工单号IsNotNull() {
            addCriterion("工单号 is not null");
            return (Criteria) this;
        }

        public Criteria and工单号EqualTo(Double value) {
            addCriterion("工单号 =", value, "工单号");
            return (Criteria) this;
        }

        public Criteria and工单号NotEqualTo(Double value) {
            addCriterion("工单号 <>", value, "工单号");
            return (Criteria) this;
        }

        public Criteria and工单号GreaterThan(Double value) {
            addCriterion("工单号 >", value, "工单号");
            return (Criteria) this;
        }

        public Criteria and工单号GreaterThanOrEqualTo(Double value) {
            addCriterion("工单号 >=", value, "工单号");
            return (Criteria) this;
        }

        public Criteria and工单号LessThan(Double value) {
            addCriterion("工单号 <", value, "工单号");
            return (Criteria) this;
        }

        public Criteria and工单号LessThanOrEqualTo(Double value) {
            addCriterion("工单号 <=", value, "工单号");
            return (Criteria) this;
        }

        public Criteria and工单号In(List<Double> values) {
            addCriterion("工单号 in", values, "工单号");
            return (Criteria) this;
        }

        public Criteria and工单号NotIn(List<Double> values) {
            addCriterion("工单号 not in", values, "工单号");
            return (Criteria) this;
        }

        public Criteria and工单号Between(Double value1, Double value2) {
            addCriterion("工单号 between", value1, value2, "工单号");
            return (Criteria) this;
        }

        public Criteria and工单号NotBetween(Double value1, Double value2) {
            addCriterion("工单号 not between", value1, value2, "工单号");
            return (Criteria) this;
        }

        public Criteria and电机识别码IsNull() {
            addCriterion("电机识别码 is null");
            return (Criteria) this;
        }

        public Criteria and电机识别码IsNotNull() {
            addCriterion("电机识别码 is not null");
            return (Criteria) this;
        }

        public Criteria and电机识别码EqualTo(String value) {
            addCriterion("电机识别码 =", value, "电机识别码");
            return (Criteria) this;
        }

        public Criteria and电机识别码NotEqualTo(String value) {
            addCriterion("电机识别码 <>", value, "电机识别码");
            return (Criteria) this;
        }

        public Criteria and电机识别码GreaterThan(String value) {
            addCriterion("电机识别码 >", value, "电机识别码");
            return (Criteria) this;
        }

        public Criteria and电机识别码GreaterThanOrEqualTo(String value) {
            addCriterion("电机识别码 >=", value, "电机识别码");
            return (Criteria) this;
        }

        public Criteria and电机识别码LessThan(String value) {
            addCriterion("电机识别码 <", value, "电机识别码");
            return (Criteria) this;
        }

        public Criteria and电机识别码LessThanOrEqualTo(String value) {
            addCriterion("电机识别码 <=", value, "电机识别码");
            return (Criteria) this;
        }

        public Criteria and电机识别码Like(String value) {
            addCriterion("电机识别码 like", value, "电机识别码");
            return (Criteria) this;
        }

        public Criteria and电机识别码NotLike(String value) {
            addCriterion("电机识别码 not like", value, "电机识别码");
            return (Criteria) this;
        }

        public Criteria and电机识别码In(List<String> values) {
            addCriterion("电机识别码 in", values, "电机识别码");
            return (Criteria) this;
        }

        public Criteria and电机识别码NotIn(List<String> values) {
            addCriterion("电机识别码 not in", values, "电机识别码");
            return (Criteria) this;
        }

        public Criteria and电机识别码Between(String value1, String value2) {
            addCriterion("电机识别码 between", value1, value2, "电机识别码");
            return (Criteria) this;
        }

        public Criteria and电机识别码NotBetween(String value1, String value2) {
            addCriterion("电机识别码 not between", value1, value2, "电机识别码");
            return (Criteria) this;
        }

        public Criteria and电机种类IsNull() {
            addCriterion("电机种类 is null");
            return (Criteria) this;
        }

        public Criteria and电机种类IsNotNull() {
            addCriterion("电机种类 is not null");
            return (Criteria) this;
        }

        public Criteria and电机种类EqualTo(String value) {
            addCriterion("电机种类 =", value, "电机种类");
            return (Criteria) this;
        }

        public Criteria and电机种类NotEqualTo(String value) {
            addCriterion("电机种类 <>", value, "电机种类");
            return (Criteria) this;
        }

        public Criteria and电机种类GreaterThan(String value) {
            addCriterion("电机种类 >", value, "电机种类");
            return (Criteria) this;
        }

        public Criteria and电机种类GreaterThanOrEqualTo(String value) {
            addCriterion("电机种类 >=", value, "电机种类");
            return (Criteria) this;
        }

        public Criteria and电机种类LessThan(String value) {
            addCriterion("电机种类 <", value, "电机种类");
            return (Criteria) this;
        }

        public Criteria and电机种类LessThanOrEqualTo(String value) {
            addCriterion("电机种类 <=", value, "电机种类");
            return (Criteria) this;
        }

        public Criteria and电机种类Like(String value) {
            addCriterion("电机种类 like", value, "电机种类");
            return (Criteria) this;
        }

        public Criteria and电机种类NotLike(String value) {
            addCriterion("电机种类 not like", value, "电机种类");
            return (Criteria) this;
        }

        public Criteria and电机种类In(List<String> values) {
            addCriterion("电机种类 in", values, "电机种类");
            return (Criteria) this;
        }

        public Criteria and电机种类NotIn(List<String> values) {
            addCriterion("电机种类 not in", values, "电机种类");
            return (Criteria) this;
        }

        public Criteria and电机种类Between(String value1, String value2) {
            addCriterion("电机种类 between", value1, value2, "电机种类");
            return (Criteria) this;
        }

        public Criteria and电机种类NotBetween(String value1, String value2) {
            addCriterion("电机种类 not between", value1, value2, "电机种类");
            return (Criteria) this;
        }

        public Criteria and气密标准值IsNull() {
            addCriterion("气密标准值 is null");
            return (Criteria) this;
        }

        public Criteria and气密标准值IsNotNull() {
            addCriterion("气密标准值 is not null");
            return (Criteria) this;
        }

        public Criteria and气密标准值EqualTo(String value) {
            addCriterion("气密标准值 =", value, "气密标准值");
            return (Criteria) this;
        }

        public Criteria and气密标准值NotEqualTo(String value) {
            addCriterion("气密标准值 <>", value, "气密标准值");
            return (Criteria) this;
        }

        public Criteria and气密标准值GreaterThan(String value) {
            addCriterion("气密标准值 >", value, "气密标准值");
            return (Criteria) this;
        }

        public Criteria and气密标准值GreaterThanOrEqualTo(String value) {
            addCriterion("气密标准值 >=", value, "气密标准值");
            return (Criteria) this;
        }

        public Criteria and气密标准值LessThan(String value) {
            addCriterion("气密标准值 <", value, "气密标准值");
            return (Criteria) this;
        }

        public Criteria and气密标准值LessThanOrEqualTo(String value) {
            addCriterion("气密标准值 <=", value, "气密标准值");
            return (Criteria) this;
        }

        public Criteria and气密标准值Like(String value) {
            addCriterion("气密标准值 like", value, "气密标准值");
            return (Criteria) this;
        }

        public Criteria and气密标准值NotLike(String value) {
            addCriterion("气密标准值 not like", value, "气密标准值");
            return (Criteria) this;
        }

        public Criteria and气密标准值In(List<String> values) {
            addCriterion("气密标准值 in", values, "气密标准值");
            return (Criteria) this;
        }

        public Criteria and气密标准值NotIn(List<String> values) {
            addCriterion("气密标准值 not in", values, "气密标准值");
            return (Criteria) this;
        }

        public Criteria and气密标准值Between(String value1, String value2) {
            addCriterion("气密标准值 between", value1, value2, "气密标准值");
            return (Criteria) this;
        }

        public Criteria and气密标准值NotBetween(String value1, String value2) {
            addCriterion("气密标准值 not between", value1, value2, "气密标准值");
            return (Criteria) this;
        }

        public Criteria and气密实测值IsNull() {
            addCriterion("气密实测值 is null");
            return (Criteria) this;
        }

        public Criteria and气密实测值IsNotNull() {
            addCriterion("气密实测值 is not null");
            return (Criteria) this;
        }

        public Criteria and气密实测值EqualTo(String value) {
            addCriterion("气密实测值 =", value, "气密实测值");
            return (Criteria) this;
        }

        public Criteria and气密实测值NotEqualTo(String value) {
            addCriterion("气密实测值 <>", value, "气密实测值");
            return (Criteria) this;
        }

        public Criteria and气密实测值GreaterThan(String value) {
            addCriterion("气密实测值 >", value, "气密实测值");
            return (Criteria) this;
        }

        public Criteria and气密实测值GreaterThanOrEqualTo(String value) {
            addCriterion("气密实测值 >=", value, "气密实测值");
            return (Criteria) this;
        }

        public Criteria and气密实测值LessThan(String value) {
            addCriterion("气密实测值 <", value, "气密实测值");
            return (Criteria) this;
        }

        public Criteria and气密实测值LessThanOrEqualTo(String value) {
            addCriterion("气密实测值 <=", value, "气密实测值");
            return (Criteria) this;
        }

        public Criteria and气密实测值Like(String value) {
            addCriterion("气密实测值 like", value, "气密实测值");
            return (Criteria) this;
        }

        public Criteria and气密实测值NotLike(String value) {
            addCriterion("气密实测值 not like", value, "气密实测值");
            return (Criteria) this;
        }

        public Criteria and气密实测值In(List<String> values) {
            addCriterion("气密实测值 in", values, "气密实测值");
            return (Criteria) this;
        }

        public Criteria and气密实测值NotIn(List<String> values) {
            addCriterion("气密实测值 not in", values, "气密实测值");
            return (Criteria) this;
        }

        public Criteria and气密实测值Between(String value1, String value2) {
            addCriterion("气密实测值 between", value1, value2, "气密实测值");
            return (Criteria) this;
        }

        public Criteria and气密实测值NotBetween(String value1, String value2) {
            addCriterion("气密实测值 not between", value1, value2, "气密实测值");
            return (Criteria) this;
        }

        public Criteria and气密测试结果IsNull() {
            addCriterion("气密测试结果 is null");
            return (Criteria) this;
        }

        public Criteria and气密测试结果IsNotNull() {
            addCriterion("气密测试结果 is not null");
            return (Criteria) this;
        }

        public Criteria and气密测试结果EqualTo(String value) {
            addCriterion("气密测试结果 =", value, "气密测试结果");
            return (Criteria) this;
        }

        public Criteria and气密测试结果NotEqualTo(String value) {
            addCriterion("气密测试结果 <>", value, "气密测试结果");
            return (Criteria) this;
        }

        public Criteria and气密测试结果GreaterThan(String value) {
            addCriterion("气密测试结果 >", value, "气密测试结果");
            return (Criteria) this;
        }

        public Criteria and气密测试结果GreaterThanOrEqualTo(String value) {
            addCriterion("气密测试结果 >=", value, "气密测试结果");
            return (Criteria) this;
        }

        public Criteria and气密测试结果LessThan(String value) {
            addCriterion("气密测试结果 <", value, "气密测试结果");
            return (Criteria) this;
        }

        public Criteria and气密测试结果LessThanOrEqualTo(String value) {
            addCriterion("气密测试结果 <=", value, "气密测试结果");
            return (Criteria) this;
        }

        public Criteria and气密测试结果Like(String value) {
            addCriterion("气密测试结果 like", value, "气密测试结果");
            return (Criteria) this;
        }

        public Criteria and气密测试结果NotLike(String value) {
            addCriterion("气密测试结果 not like", value, "气密测试结果");
            return (Criteria) this;
        }

        public Criteria and气密测试结果In(List<String> values) {
            addCriterion("气密测试结果 in", values, "气密测试结果");
            return (Criteria) this;
        }

        public Criteria and气密测试结果NotIn(List<String> values) {
            addCriterion("气密测试结果 not in", values, "气密测试结果");
            return (Criteria) this;
        }

        public Criteria and气密测试结果Between(String value1, String value2) {
            addCriterion("气密测试结果 between", value1, value2, "气密测试结果");
            return (Criteria) this;
        }

        public Criteria and气密测试结果NotBetween(String value1, String value2) {
            addCriterion("气密测试结果 not between", value1, value2, "气密测试结果");
            return (Criteria) this;
        }

        public Criteria and油量标准值IsNull() {
            addCriterion("油量标准值 is null");
            return (Criteria) this;
        }

        public Criteria and油量标准值IsNotNull() {
            addCriterion("油量标准值 is not null");
            return (Criteria) this;
        }

        public Criteria and油量标准值EqualTo(String value) {
            addCriterion("油量标准值 =", value, "油量标准值");
            return (Criteria) this;
        }

        public Criteria and油量标准值NotEqualTo(String value) {
            addCriterion("油量标准值 <>", value, "油量标准值");
            return (Criteria) this;
        }

        public Criteria and油量标准值GreaterThan(String value) {
            addCriterion("油量标准值 >", value, "油量标准值");
            return (Criteria) this;
        }

        public Criteria and油量标准值GreaterThanOrEqualTo(String value) {
            addCriterion("油量标准值 >=", value, "油量标准值");
            return (Criteria) this;
        }

        public Criteria and油量标准值LessThan(String value) {
            addCriterion("油量标准值 <", value, "油量标准值");
            return (Criteria) this;
        }

        public Criteria and油量标准值LessThanOrEqualTo(String value) {
            addCriterion("油量标准值 <=", value, "油量标准值");
            return (Criteria) this;
        }

        public Criteria and油量标准值Like(String value) {
            addCriterion("油量标准值 like", value, "油量标准值");
            return (Criteria) this;
        }

        public Criteria and油量标准值NotLike(String value) {
            addCriterion("油量标准值 not like", value, "油量标准值");
            return (Criteria) this;
        }

        public Criteria and油量标准值In(List<String> values) {
            addCriterion("油量标准值 in", values, "油量标准值");
            return (Criteria) this;
        }

        public Criteria and油量标准值NotIn(List<String> values) {
            addCriterion("油量标准值 not in", values, "油量标准值");
            return (Criteria) this;
        }

        public Criteria and油量标准值Between(String value1, String value2) {
            addCriterion("油量标准值 between", value1, value2, "油量标准值");
            return (Criteria) this;
        }

        public Criteria and油量标准值NotBetween(String value1, String value2) {
            addCriterion("油量标准值 not between", value1, value2, "油量标准值");
            return (Criteria) this;
        }

        public Criteria and实注油量值IsNull() {
            addCriterion("实注油量值 is null");
            return (Criteria) this;
        }

        public Criteria and实注油量值IsNotNull() {
            addCriterion("实注油量值 is not null");
            return (Criteria) this;
        }

        public Criteria and实注油量值EqualTo(String value) {
            addCriterion("实注油量值 =", value, "实注油量值");
            return (Criteria) this;
        }

        public Criteria and实注油量值NotEqualTo(String value) {
            addCriterion("实注油量值 <>", value, "实注油量值");
            return (Criteria) this;
        }

        public Criteria and实注油量值GreaterThan(String value) {
            addCriterion("实注油量值 >", value, "实注油量值");
            return (Criteria) this;
        }

        public Criteria and实注油量值GreaterThanOrEqualTo(String value) {
            addCriterion("实注油量值 >=", value, "实注油量值");
            return (Criteria) this;
        }

        public Criteria and实注油量值LessThan(String value) {
            addCriterion("实注油量值 <", value, "实注油量值");
            return (Criteria) this;
        }

        public Criteria and实注油量值LessThanOrEqualTo(String value) {
            addCriterion("实注油量值 <=", value, "实注油量值");
            return (Criteria) this;
        }

        public Criteria and实注油量值Like(String value) {
            addCriterion("实注油量值 like", value, "实注油量值");
            return (Criteria) this;
        }

        public Criteria and实注油量值NotLike(String value) {
            addCriterion("实注油量值 not like", value, "实注油量值");
            return (Criteria) this;
        }

        public Criteria and实注油量值In(List<String> values) {
            addCriterion("实注油量值 in", values, "实注油量值");
            return (Criteria) this;
        }

        public Criteria and实注油量值NotIn(List<String> values) {
            addCriterion("实注油量值 not in", values, "实注油量值");
            return (Criteria) this;
        }

        public Criteria and实注油量值Between(String value1, String value2) {
            addCriterion("实注油量值 between", value1, value2, "实注油量值");
            return (Criteria) this;
        }

        public Criteria and实注油量值NotBetween(String value1, String value2) {
            addCriterion("实注油量值 not between", value1, value2, "实注油量值");
            return (Criteria) this;
        }

        public Criteria and注油测试结果IsNull() {
            addCriterion("注油测试结果 is null");
            return (Criteria) this;
        }

        public Criteria and注油测试结果IsNotNull() {
            addCriterion("注油测试结果 is not null");
            return (Criteria) this;
        }

        public Criteria and注油测试结果EqualTo(String value) {
            addCriterion("注油测试结果 =", value, "注油测试结果");
            return (Criteria) this;
        }

        public Criteria and注油测试结果NotEqualTo(String value) {
            addCriterion("注油测试结果 <>", value, "注油测试结果");
            return (Criteria) this;
        }

        public Criteria and注油测试结果GreaterThan(String value) {
            addCriterion("注油测试结果 >", value, "注油测试结果");
            return (Criteria) this;
        }

        public Criteria and注油测试结果GreaterThanOrEqualTo(String value) {
            addCriterion("注油测试结果 >=", value, "注油测试结果");
            return (Criteria) this;
        }

        public Criteria and注油测试结果LessThan(String value) {
            addCriterion("注油测试结果 <", value, "注油测试结果");
            return (Criteria) this;
        }

        public Criteria and注油测试结果LessThanOrEqualTo(String value) {
            addCriterion("注油测试结果 <=", value, "注油测试结果");
            return (Criteria) this;
        }

        public Criteria and注油测试结果Like(String value) {
            addCriterion("注油测试结果 like", value, "注油测试结果");
            return (Criteria) this;
        }

        public Criteria and注油测试结果NotLike(String value) {
            addCriterion("注油测试结果 not like", value, "注油测试结果");
            return (Criteria) this;
        }

        public Criteria and注油测试结果In(List<String> values) {
            addCriterion("注油测试结果 in", values, "注油测试结果");
            return (Criteria) this;
        }

        public Criteria and注油测试结果NotIn(List<String> values) {
            addCriterion("注油测试结果 not in", values, "注油测试结果");
            return (Criteria) this;
        }

        public Criteria and注油测试结果Between(String value1, String value2) {
            addCriterion("注油测试结果 between", value1, value2, "注油测试结果");
            return (Criteria) this;
        }

        public Criteria and注油测试结果NotBetween(String value1, String value2) {
            addCriterion("注油测试结果 not between", value1, value2, "注油测试结果");
            return (Criteria) this;
        }

        public Criteria and电阻标准值IsNull() {
            addCriterion("电阻标准值 is null");
            return (Criteria) this;
        }

        public Criteria and电阻标准值IsNotNull() {
            addCriterion("电阻标准值 is not null");
            return (Criteria) this;
        }

        public Criteria and电阻标准值EqualTo(String value) {
            addCriterion("电阻标准值 =", value, "电阻标准值");
            return (Criteria) this;
        }

        public Criteria and电阻标准值NotEqualTo(String value) {
            addCriterion("电阻标准值 <>", value, "电阻标准值");
            return (Criteria) this;
        }

        public Criteria and电阻标准值GreaterThan(String value) {
            addCriterion("电阻标准值 >", value, "电阻标准值");
            return (Criteria) this;
        }

        public Criteria and电阻标准值GreaterThanOrEqualTo(String value) {
            addCriterion("电阻标准值 >=", value, "电阻标准值");
            return (Criteria) this;
        }

        public Criteria and电阻标准值LessThan(String value) {
            addCriterion("电阻标准值 <", value, "电阻标准值");
            return (Criteria) this;
        }

        public Criteria and电阻标准值LessThanOrEqualTo(String value) {
            addCriterion("电阻标准值 <=", value, "电阻标准值");
            return (Criteria) this;
        }

        public Criteria and电阻标准值Like(String value) {
            addCriterion("电阻标准值 like", value, "电阻标准值");
            return (Criteria) this;
        }

        public Criteria and电阻标准值NotLike(String value) {
            addCriterion("电阻标准值 not like", value, "电阻标准值");
            return (Criteria) this;
        }

        public Criteria and电阻标准值In(List<String> values) {
            addCriterion("电阻标准值 in", values, "电阻标准值");
            return (Criteria) this;
        }

        public Criteria and电阻标准值NotIn(List<String> values) {
            addCriterion("电阻标准值 not in", values, "电阻标准值");
            return (Criteria) this;
        }

        public Criteria and电阻标准值Between(String value1, String value2) {
            addCriterion("电阻标准值 between", value1, value2, "电阻标准值");
            return (Criteria) this;
        }

        public Criteria and电阻标准值NotBetween(String value1, String value2) {
            addCriterion("电阻标准值 not between", value1, value2, "电阻标准值");
            return (Criteria) this;
        }

        public Criteria and电阻实测值1IsNull() {
            addCriterion("电阻实测值1 is null");
            return (Criteria) this;
        }

        public Criteria and电阻实测值1IsNotNull() {
            addCriterion("电阻实测值1 is not null");
            return (Criteria) this;
        }

        public Criteria and电阻实测值1EqualTo(String value) {
            addCriterion("电阻实测值1 =", value, "电阻实测值1");
            return (Criteria) this;
        }

        public Criteria and电阻实测值1NotEqualTo(String value) {
            addCriterion("电阻实测值1 <>", value, "电阻实测值1");
            return (Criteria) this;
        }

        public Criteria and电阻实测值1GreaterThan(String value) {
            addCriterion("电阻实测值1 >", value, "电阻实测值1");
            return (Criteria) this;
        }

        public Criteria and电阻实测值1GreaterThanOrEqualTo(String value) {
            addCriterion("电阻实测值1 >=", value, "电阻实测值1");
            return (Criteria) this;
        }

        public Criteria and电阻实测值1LessThan(String value) {
            addCriterion("电阻实测值1 <", value, "电阻实测值1");
            return (Criteria) this;
        }

        public Criteria and电阻实测值1LessThanOrEqualTo(String value) {
            addCriterion("电阻实测值1 <=", value, "电阻实测值1");
            return (Criteria) this;
        }

        public Criteria and电阻实测值1Like(String value) {
            addCriterion("电阻实测值1 like", value, "电阻实测值1");
            return (Criteria) this;
        }

        public Criteria and电阻实测值1NotLike(String value) {
            addCriterion("电阻实测值1 not like", value, "电阻实测值1");
            return (Criteria) this;
        }

        public Criteria and电阻实测值1In(List<String> values) {
            addCriterion("电阻实测值1 in", values, "电阻实测值1");
            return (Criteria) this;
        }

        public Criteria and电阻实测值1NotIn(List<String> values) {
            addCriterion("电阻实测值1 not in", values, "电阻实测值1");
            return (Criteria) this;
        }

        public Criteria and电阻实测值1Between(String value1, String value2) {
            addCriterion("电阻实测值1 between", value1, value2, "电阻实测值1");
            return (Criteria) this;
        }

        public Criteria and电阻实测值1NotBetween(String value1, String value2) {
            addCriterion("电阻实测值1 not between", value1, value2, "电阻实测值1");
            return (Criteria) this;
        }

        public Criteria and电阻实测值2IsNull() {
            addCriterion("电阻实测值2 is null");
            return (Criteria) this;
        }

        public Criteria and电阻实测值2IsNotNull() {
            addCriterion("电阻实测值2 is not null");
            return (Criteria) this;
        }

        public Criteria and电阻实测值2EqualTo(String value) {
            addCriterion("电阻实测值2 =", value, "电阻实测值2");
            return (Criteria) this;
        }

        public Criteria and电阻实测值2NotEqualTo(String value) {
            addCriterion("电阻实测值2 <>", value, "电阻实测值2");
            return (Criteria) this;
        }

        public Criteria and电阻实测值2GreaterThan(String value) {
            addCriterion("电阻实测值2 >", value, "电阻实测值2");
            return (Criteria) this;
        }

        public Criteria and电阻实测值2GreaterThanOrEqualTo(String value) {
            addCriterion("电阻实测值2 >=", value, "电阻实测值2");
            return (Criteria) this;
        }

        public Criteria and电阻实测值2LessThan(String value) {
            addCriterion("电阻实测值2 <", value, "电阻实测值2");
            return (Criteria) this;
        }

        public Criteria and电阻实测值2LessThanOrEqualTo(String value) {
            addCriterion("电阻实测值2 <=", value, "电阻实测值2");
            return (Criteria) this;
        }

        public Criteria and电阻实测值2Like(String value) {
            addCriterion("电阻实测值2 like", value, "电阻实测值2");
            return (Criteria) this;
        }

        public Criteria and电阻实测值2NotLike(String value) {
            addCriterion("电阻实测值2 not like", value, "电阻实测值2");
            return (Criteria) this;
        }

        public Criteria and电阻实测值2In(List<String> values) {
            addCriterion("电阻实测值2 in", values, "电阻实测值2");
            return (Criteria) this;
        }

        public Criteria and电阻实测值2NotIn(List<String> values) {
            addCriterion("电阻实测值2 not in", values, "电阻实测值2");
            return (Criteria) this;
        }

        public Criteria and电阻实测值2Between(String value1, String value2) {
            addCriterion("电阻实测值2 between", value1, value2, "电阻实测值2");
            return (Criteria) this;
        }

        public Criteria and电阻实测值2NotBetween(String value1, String value2) {
            addCriterion("电阻实测值2 not between", value1, value2, "电阻实测值2");
            return (Criteria) this;
        }

        public Criteria and电阻实测值3IsNull() {
            addCriterion("电阻实测值3 is null");
            return (Criteria) this;
        }

        public Criteria and电阻实测值3IsNotNull() {
            addCriterion("电阻实测值3 is not null");
            return (Criteria) this;
        }

        public Criteria and电阻实测值3EqualTo(String value) {
            addCriterion("电阻实测值3 =", value, "电阻实测值3");
            return (Criteria) this;
        }

        public Criteria and电阻实测值3NotEqualTo(String value) {
            addCriterion("电阻实测值3 <>", value, "电阻实测值3");
            return (Criteria) this;
        }

        public Criteria and电阻实测值3GreaterThan(String value) {
            addCriterion("电阻实测值3 >", value, "电阻实测值3");
            return (Criteria) this;
        }

        public Criteria and电阻实测值3GreaterThanOrEqualTo(String value) {
            addCriterion("电阻实测值3 >=", value, "电阻实测值3");
            return (Criteria) this;
        }

        public Criteria and电阻实测值3LessThan(String value) {
            addCriterion("电阻实测值3 <", value, "电阻实测值3");
            return (Criteria) this;
        }

        public Criteria and电阻实测值3LessThanOrEqualTo(String value) {
            addCriterion("电阻实测值3 <=", value, "电阻实测值3");
            return (Criteria) this;
        }

        public Criteria and电阻实测值3Like(String value) {
            addCriterion("电阻实测值3 like", value, "电阻实测值3");
            return (Criteria) this;
        }

        public Criteria and电阻实测值3NotLike(String value) {
            addCriterion("电阻实测值3 not like", value, "电阻实测值3");
            return (Criteria) this;
        }

        public Criteria and电阻实测值3In(List<String> values) {
            addCriterion("电阻实测值3 in", values, "电阻实测值3");
            return (Criteria) this;
        }

        public Criteria and电阻实测值3NotIn(List<String> values) {
            addCriterion("电阻实测值3 not in", values, "电阻实测值3");
            return (Criteria) this;
        }

        public Criteria and电阻实测值3Between(String value1, String value2) {
            addCriterion("电阻实测值3 between", value1, value2, "电阻实测值3");
            return (Criteria) this;
        }

        public Criteria and电阻实测值3NotBetween(String value1, String value2) {
            addCriterion("电阻实测值3 not between", value1, value2, "电阻实测值3");
            return (Criteria) this;
        }

        public Criteria and电阻实测值结果IsNull() {
            addCriterion("电阻实测值结果 is null");
            return (Criteria) this;
        }

        public Criteria and电阻实测值结果IsNotNull() {
            addCriterion("电阻实测值结果 is not null");
            return (Criteria) this;
        }

        public Criteria and电阻实测值结果EqualTo(String value) {
            addCriterion("电阻实测值结果 =", value, "电阻实测值结果");
            return (Criteria) this;
        }

        public Criteria and电阻实测值结果NotEqualTo(String value) {
            addCriterion("电阻实测值结果 <>", value, "电阻实测值结果");
            return (Criteria) this;
        }

        public Criteria and电阻实测值结果GreaterThan(String value) {
            addCriterion("电阻实测值结果 >", value, "电阻实测值结果");
            return (Criteria) this;
        }

        public Criteria and电阻实测值结果GreaterThanOrEqualTo(String value) {
            addCriterion("电阻实测值结果 >=", value, "电阻实测值结果");
            return (Criteria) this;
        }

        public Criteria and电阻实测值结果LessThan(String value) {
            addCriterion("电阻实测值结果 <", value, "电阻实测值结果");
            return (Criteria) this;
        }

        public Criteria and电阻实测值结果LessThanOrEqualTo(String value) {
            addCriterion("电阻实测值结果 <=", value, "电阻实测值结果");
            return (Criteria) this;
        }

        public Criteria and电阻实测值结果Like(String value) {
            addCriterion("电阻实测值结果 like", value, "电阻实测值结果");
            return (Criteria) this;
        }

        public Criteria and电阻实测值结果NotLike(String value) {
            addCriterion("电阻实测值结果 not like", value, "电阻实测值结果");
            return (Criteria) this;
        }

        public Criteria and电阻实测值结果In(List<String> values) {
            addCriterion("电阻实测值结果 in", values, "电阻实测值结果");
            return (Criteria) this;
        }

        public Criteria and电阻实测值结果NotIn(List<String> values) {
            addCriterion("电阻实测值结果 not in", values, "电阻实测值结果");
            return (Criteria) this;
        }

        public Criteria and电阻实测值结果Between(String value1, String value2) {
            addCriterion("电阻实测值结果 between", value1, value2, "电阻实测值结果");
            return (Criteria) this;
        }

        public Criteria and电阻实测值结果NotBetween(String value1, String value2) {
            addCriterion("电阻实测值结果 not between", value1, value2, "电阻实测值结果");
            return (Criteria) this;
        }

        public Criteria and电阻平衡度标准值IsNull() {
            addCriterion("电阻平衡度标准值 is null");
            return (Criteria) this;
        }

        public Criteria and电阻平衡度标准值IsNotNull() {
            addCriterion("电阻平衡度标准值 is not null");
            return (Criteria) this;
        }

        public Criteria and电阻平衡度标准值EqualTo(String value) {
            addCriterion("电阻平衡度标准值 =", value, "电阻平衡度标准值");
            return (Criteria) this;
        }

        public Criteria and电阻平衡度标准值NotEqualTo(String value) {
            addCriterion("电阻平衡度标准值 <>", value, "电阻平衡度标准值");
            return (Criteria) this;
        }

        public Criteria and电阻平衡度标准值GreaterThan(String value) {
            addCriterion("电阻平衡度标准值 >", value, "电阻平衡度标准值");
            return (Criteria) this;
        }

        public Criteria and电阻平衡度标准值GreaterThanOrEqualTo(String value) {
            addCriterion("电阻平衡度标准值 >=", value, "电阻平衡度标准值");
            return (Criteria) this;
        }

        public Criteria and电阻平衡度标准值LessThan(String value) {
            addCriterion("电阻平衡度标准值 <", value, "电阻平衡度标准值");
            return (Criteria) this;
        }

        public Criteria and电阻平衡度标准值LessThanOrEqualTo(String value) {
            addCriterion("电阻平衡度标准值 <=", value, "电阻平衡度标准值");
            return (Criteria) this;
        }

        public Criteria and电阻平衡度标准值Like(String value) {
            addCriterion("电阻平衡度标准值 like", value, "电阻平衡度标准值");
            return (Criteria) this;
        }

        public Criteria and电阻平衡度标准值NotLike(String value) {
            addCriterion("电阻平衡度标准值 not like", value, "电阻平衡度标准值");
            return (Criteria) this;
        }

        public Criteria and电阻平衡度标准值In(List<String> values) {
            addCriterion("电阻平衡度标准值 in", values, "电阻平衡度标准值");
            return (Criteria) this;
        }

        public Criteria and电阻平衡度标准值NotIn(List<String> values) {
            addCriterion("电阻平衡度标准值 not in", values, "电阻平衡度标准值");
            return (Criteria) this;
        }

        public Criteria and电阻平衡度标准值Between(String value1, String value2) {
            addCriterion("电阻平衡度标准值 between", value1, value2, "电阻平衡度标准值");
            return (Criteria) this;
        }

        public Criteria and电阻平衡度标准值NotBetween(String value1, String value2) {
            addCriterion("电阻平衡度标准值 not between", value1, value2, "电阻平衡度标准值");
            return (Criteria) this;
        }

        public Criteria and电阻平衡度实测值IsNull() {
            addCriterion("电阻平衡度实测值 is null");
            return (Criteria) this;
        }

        public Criteria and电阻平衡度实测值IsNotNull() {
            addCriterion("电阻平衡度实测值 is not null");
            return (Criteria) this;
        }

        public Criteria and电阻平衡度实测值EqualTo(String value) {
            addCriterion("电阻平衡度实测值 =", value, "电阻平衡度实测值");
            return (Criteria) this;
        }

        public Criteria and电阻平衡度实测值NotEqualTo(String value) {
            addCriterion("电阻平衡度实测值 <>", value, "电阻平衡度实测值");
            return (Criteria) this;
        }

        public Criteria and电阻平衡度实测值GreaterThan(String value) {
            addCriterion("电阻平衡度实测值 >", value, "电阻平衡度实测值");
            return (Criteria) this;
        }

        public Criteria and电阻平衡度实测值GreaterThanOrEqualTo(String value) {
            addCriterion("电阻平衡度实测值 >=", value, "电阻平衡度实测值");
            return (Criteria) this;
        }

        public Criteria and电阻平衡度实测值LessThan(String value) {
            addCriterion("电阻平衡度实测值 <", value, "电阻平衡度实测值");
            return (Criteria) this;
        }

        public Criteria and电阻平衡度实测值LessThanOrEqualTo(String value) {
            addCriterion("电阻平衡度实测值 <=", value, "电阻平衡度实测值");
            return (Criteria) this;
        }

        public Criteria and电阻平衡度实测值Like(String value) {
            addCriterion("电阻平衡度实测值 like", value, "电阻平衡度实测值");
            return (Criteria) this;
        }

        public Criteria and电阻平衡度实测值NotLike(String value) {
            addCriterion("电阻平衡度实测值 not like", value, "电阻平衡度实测值");
            return (Criteria) this;
        }

        public Criteria and电阻平衡度实测值In(List<String> values) {
            addCriterion("电阻平衡度实测值 in", values, "电阻平衡度实测值");
            return (Criteria) this;
        }

        public Criteria and电阻平衡度实测值NotIn(List<String> values) {
            addCriterion("电阻平衡度实测值 not in", values, "电阻平衡度实测值");
            return (Criteria) this;
        }

        public Criteria and电阻平衡度实测值Between(String value1, String value2) {
            addCriterion("电阻平衡度实测值 between", value1, value2, "电阻平衡度实测值");
            return (Criteria) this;
        }

        public Criteria and电阻平衡度实测值NotBetween(String value1, String value2) {
            addCriterion("电阻平衡度实测值 not between", value1, value2, "电阻平衡度实测值");
            return (Criteria) this;
        }

        public Criteria and电阻平衡度测试结果IsNull() {
            addCriterion("电阻平衡度测试结果 is null");
            return (Criteria) this;
        }

        public Criteria and电阻平衡度测试结果IsNotNull() {
            addCriterion("电阻平衡度测试结果 is not null");
            return (Criteria) this;
        }

        public Criteria and电阻平衡度测试结果EqualTo(String value) {
            addCriterion("电阻平衡度测试结果 =", value, "电阻平衡度测试结果");
            return (Criteria) this;
        }

        public Criteria and电阻平衡度测试结果NotEqualTo(String value) {
            addCriterion("电阻平衡度测试结果 <>", value, "电阻平衡度测试结果");
            return (Criteria) this;
        }

        public Criteria and电阻平衡度测试结果GreaterThan(String value) {
            addCriterion("电阻平衡度测试结果 >", value, "电阻平衡度测试结果");
            return (Criteria) this;
        }

        public Criteria and电阻平衡度测试结果GreaterThanOrEqualTo(String value) {
            addCriterion("电阻平衡度测试结果 >=", value, "电阻平衡度测试结果");
            return (Criteria) this;
        }

        public Criteria and电阻平衡度测试结果LessThan(String value) {
            addCriterion("电阻平衡度测试结果 <", value, "电阻平衡度测试结果");
            return (Criteria) this;
        }

        public Criteria and电阻平衡度测试结果LessThanOrEqualTo(String value) {
            addCriterion("电阻平衡度测试结果 <=", value, "电阻平衡度测试结果");
            return (Criteria) this;
        }

        public Criteria and电阻平衡度测试结果Like(String value) {
            addCriterion("电阻平衡度测试结果 like", value, "电阻平衡度测试结果");
            return (Criteria) this;
        }

        public Criteria and电阻平衡度测试结果NotLike(String value) {
            addCriterion("电阻平衡度测试结果 not like", value, "电阻平衡度测试结果");
            return (Criteria) this;
        }

        public Criteria and电阻平衡度测试结果In(List<String> values) {
            addCriterion("电阻平衡度测试结果 in", values, "电阻平衡度测试结果");
            return (Criteria) this;
        }

        public Criteria and电阻平衡度测试结果NotIn(List<String> values) {
            addCriterion("电阻平衡度测试结果 not in", values, "电阻平衡度测试结果");
            return (Criteria) this;
        }

        public Criteria and电阻平衡度测试结果Between(String value1, String value2) {
            addCriterion("电阻平衡度测试结果 between", value1, value2, "电阻平衡度测试结果");
            return (Criteria) this;
        }

        public Criteria and电阻平衡度测试结果NotBetween(String value1, String value2) {
            addCriterion("电阻平衡度测试结果 not between", value1, value2, "电阻平衡度测试结果");
            return (Criteria) this;
        }

        public Criteria and绝缘电压IsNull() {
            addCriterion("绝缘电压 is null");
            return (Criteria) this;
        }

        public Criteria and绝缘电压IsNotNull() {
            addCriterion("绝缘电压 is not null");
            return (Criteria) this;
        }

        public Criteria and绝缘电压EqualTo(Double value) {
            addCriterion("绝缘电压 =", value, "绝缘电压");
            return (Criteria) this;
        }

        public Criteria and绝缘电压NotEqualTo(Double value) {
            addCriterion("绝缘电压 <>", value, "绝缘电压");
            return (Criteria) this;
        }

        public Criteria and绝缘电压GreaterThan(Double value) {
            addCriterion("绝缘电压 >", value, "绝缘电压");
            return (Criteria) this;
        }

        public Criteria and绝缘电压GreaterThanOrEqualTo(Double value) {
            addCriterion("绝缘电压 >=", value, "绝缘电压");
            return (Criteria) this;
        }

        public Criteria and绝缘电压LessThan(Double value) {
            addCriterion("绝缘电压 <", value, "绝缘电压");
            return (Criteria) this;
        }

        public Criteria and绝缘电压LessThanOrEqualTo(Double value) {
            addCriterion("绝缘电压 <=", value, "绝缘电压");
            return (Criteria) this;
        }

        public Criteria and绝缘电压In(List<Double> values) {
            addCriterion("绝缘电压 in", values, "绝缘电压");
            return (Criteria) this;
        }

        public Criteria and绝缘电压NotIn(List<Double> values) {
            addCriterion("绝缘电压 not in", values, "绝缘电压");
            return (Criteria) this;
        }

        public Criteria and绝缘电压Between(Double value1, Double value2) {
            addCriterion("绝缘电压 between", value1, value2, "绝缘电压");
            return (Criteria) this;
        }

        public Criteria and绝缘电压NotBetween(Double value1, Double value2) {
            addCriterion("绝缘电压 not between", value1, value2, "绝缘电压");
            return (Criteria) this;
        }

        public Criteria and绝缘标准值IsNull() {
            addCriterion("绝缘标准值 is null");
            return (Criteria) this;
        }

        public Criteria and绝缘标准值IsNotNull() {
            addCriterion("绝缘标准值 is not null");
            return (Criteria) this;
        }

        public Criteria and绝缘标准值EqualTo(Double value) {
            addCriterion("绝缘标准值 =", value, "绝缘标准值");
            return (Criteria) this;
        }

        public Criteria and绝缘标准值NotEqualTo(Double value) {
            addCriterion("绝缘标准值 <>", value, "绝缘标准值");
            return (Criteria) this;
        }

        public Criteria and绝缘标准值GreaterThan(Double value) {
            addCriterion("绝缘标准值 >", value, "绝缘标准值");
            return (Criteria) this;
        }

        public Criteria and绝缘标准值GreaterThanOrEqualTo(Double value) {
            addCriterion("绝缘标准值 >=", value, "绝缘标准值");
            return (Criteria) this;
        }

        public Criteria and绝缘标准值LessThan(Double value) {
            addCriterion("绝缘标准值 <", value, "绝缘标准值");
            return (Criteria) this;
        }

        public Criteria and绝缘标准值LessThanOrEqualTo(Double value) {
            addCriterion("绝缘标准值 <=", value, "绝缘标准值");
            return (Criteria) this;
        }

        public Criteria and绝缘标准值In(List<Double> values) {
            addCriterion("绝缘标准值 in", values, "绝缘标准值");
            return (Criteria) this;
        }

        public Criteria and绝缘标准值NotIn(List<Double> values) {
            addCriterion("绝缘标准值 not in", values, "绝缘标准值");
            return (Criteria) this;
        }

        public Criteria and绝缘标准值Between(Double value1, Double value2) {
            addCriterion("绝缘标准值 between", value1, value2, "绝缘标准值");
            return (Criteria) this;
        }

        public Criteria and绝缘标准值NotBetween(Double value1, Double value2) {
            addCriterion("绝缘标准值 not between", value1, value2, "绝缘标准值");
            return (Criteria) this;
        }

        public Criteria and实测绝电阻IsNull() {
            addCriterion("实测绝电阻 is null");
            return (Criteria) this;
        }

        public Criteria and实测绝电阻IsNotNull() {
            addCriterion("实测绝电阻 is not null");
            return (Criteria) this;
        }

        public Criteria and实测绝电阻EqualTo(String value) {
            addCriterion("实测绝电阻 =", value, "实测绝电阻");
            return (Criteria) this;
        }

        public Criteria and实测绝电阻NotEqualTo(String value) {
            addCriterion("实测绝电阻 <>", value, "实测绝电阻");
            return (Criteria) this;
        }

        public Criteria and实测绝电阻GreaterThan(String value) {
            addCriterion("实测绝电阻 >", value, "实测绝电阻");
            return (Criteria) this;
        }

        public Criteria and实测绝电阻GreaterThanOrEqualTo(String value) {
            addCriterion("实测绝电阻 >=", value, "实测绝电阻");
            return (Criteria) this;
        }

        public Criteria and实测绝电阻LessThan(String value) {
            addCriterion("实测绝电阻 <", value, "实测绝电阻");
            return (Criteria) this;
        }

        public Criteria and实测绝电阻LessThanOrEqualTo(String value) {
            addCriterion("实测绝电阻 <=", value, "实测绝电阻");
            return (Criteria) this;
        }

        public Criteria and实测绝电阻Like(String value) {
            addCriterion("实测绝电阻 like", value, "实测绝电阻");
            return (Criteria) this;
        }

        public Criteria and实测绝电阻NotLike(String value) {
            addCriterion("实测绝电阻 not like", value, "实测绝电阻");
            return (Criteria) this;
        }

        public Criteria and实测绝电阻In(List<String> values) {
            addCriterion("实测绝电阻 in", values, "实测绝电阻");
            return (Criteria) this;
        }

        public Criteria and实测绝电阻NotIn(List<String> values) {
            addCriterion("实测绝电阻 not in", values, "实测绝电阻");
            return (Criteria) this;
        }

        public Criteria and实测绝电阻Between(String value1, String value2) {
            addCriterion("实测绝电阻 between", value1, value2, "实测绝电阻");
            return (Criteria) this;
        }

        public Criteria and实测绝电阻NotBetween(String value1, String value2) {
            addCriterion("实测绝电阻 not between", value1, value2, "实测绝电阻");
            return (Criteria) this;
        }

        public Criteria and绝缘测试结果IsNull() {
            addCriterion("绝缘测试结果 is null");
            return (Criteria) this;
        }

        public Criteria and绝缘测试结果IsNotNull() {
            addCriterion("绝缘测试结果 is not null");
            return (Criteria) this;
        }

        public Criteria and绝缘测试结果EqualTo(String value) {
            addCriterion("绝缘测试结果 =", value, "绝缘测试结果");
            return (Criteria) this;
        }

        public Criteria and绝缘测试结果NotEqualTo(String value) {
            addCriterion("绝缘测试结果 <>", value, "绝缘测试结果");
            return (Criteria) this;
        }

        public Criteria and绝缘测试结果GreaterThan(String value) {
            addCriterion("绝缘测试结果 >", value, "绝缘测试结果");
            return (Criteria) this;
        }

        public Criteria and绝缘测试结果GreaterThanOrEqualTo(String value) {
            addCriterion("绝缘测试结果 >=", value, "绝缘测试结果");
            return (Criteria) this;
        }

        public Criteria and绝缘测试结果LessThan(String value) {
            addCriterion("绝缘测试结果 <", value, "绝缘测试结果");
            return (Criteria) this;
        }

        public Criteria and绝缘测试结果LessThanOrEqualTo(String value) {
            addCriterion("绝缘测试结果 <=", value, "绝缘测试结果");
            return (Criteria) this;
        }

        public Criteria and绝缘测试结果Like(String value) {
            addCriterion("绝缘测试结果 like", value, "绝缘测试结果");
            return (Criteria) this;
        }

        public Criteria and绝缘测试结果NotLike(String value) {
            addCriterion("绝缘测试结果 not like", value, "绝缘测试结果");
            return (Criteria) this;
        }

        public Criteria and绝缘测试结果In(List<String> values) {
            addCriterion("绝缘测试结果 in", values, "绝缘测试结果");
            return (Criteria) this;
        }

        public Criteria and绝缘测试结果NotIn(List<String> values) {
            addCriterion("绝缘测试结果 not in", values, "绝缘测试结果");
            return (Criteria) this;
        }

        public Criteria and绝缘测试结果Between(String value1, String value2) {
            addCriterion("绝缘测试结果 between", value1, value2, "绝缘测试结果");
            return (Criteria) this;
        }

        public Criteria and绝缘测试结果NotBetween(String value1, String value2) {
            addCriterion("绝缘测试结果 not between", value1, value2, "绝缘测试结果");
            return (Criteria) this;
        }

        public Criteria and匝间电压IsNull() {
            addCriterion("匝间电压 is null");
            return (Criteria) this;
        }

        public Criteria and匝间电压IsNotNull() {
            addCriterion("匝间电压 is not null");
            return (Criteria) this;
        }

        public Criteria and匝间电压EqualTo(String value) {
            addCriterion("匝间电压 =", value, "匝间电压");
            return (Criteria) this;
        }

        public Criteria and匝间电压NotEqualTo(String value) {
            addCriterion("匝间电压 <>", value, "匝间电压");
            return (Criteria) this;
        }

        public Criteria and匝间电压GreaterThan(String value) {
            addCriterion("匝间电压 >", value, "匝间电压");
            return (Criteria) this;
        }

        public Criteria and匝间电压GreaterThanOrEqualTo(String value) {
            addCriterion("匝间电压 >=", value, "匝间电压");
            return (Criteria) this;
        }

        public Criteria and匝间电压LessThan(String value) {
            addCriterion("匝间电压 <", value, "匝间电压");
            return (Criteria) this;
        }

        public Criteria and匝间电压LessThanOrEqualTo(String value) {
            addCriterion("匝间电压 <=", value, "匝间电压");
            return (Criteria) this;
        }

        public Criteria and匝间电压Like(String value) {
            addCriterion("匝间电压 like", value, "匝间电压");
            return (Criteria) this;
        }

        public Criteria and匝间电压NotLike(String value) {
            addCriterion("匝间电压 not like", value, "匝间电压");
            return (Criteria) this;
        }

        public Criteria and匝间电压In(List<String> values) {
            addCriterion("匝间电压 in", values, "匝间电压");
            return (Criteria) this;
        }

        public Criteria and匝间电压NotIn(List<String> values) {
            addCriterion("匝间电压 not in", values, "匝间电压");
            return (Criteria) this;
        }

        public Criteria and匝间电压Between(String value1, String value2) {
            addCriterion("匝间电压 between", value1, value2, "匝间电压");
            return (Criteria) this;
        }

        public Criteria and匝间电压NotBetween(String value1, String value2) {
            addCriterion("匝间电压 not between", value1, value2, "匝间电压");
            return (Criteria) this;
        }

        public Criteria and匝间标准值IsNull() {
            addCriterion("匝间标准值 is null");
            return (Criteria) this;
        }

        public Criteria and匝间标准值IsNotNull() {
            addCriterion("匝间标准值 is not null");
            return (Criteria) this;
        }

        public Criteria and匝间标准值EqualTo(String value) {
            addCriterion("匝间标准值 =", value, "匝间标准值");
            return (Criteria) this;
        }

        public Criteria and匝间标准值NotEqualTo(String value) {
            addCriterion("匝间标准值 <>", value, "匝间标准值");
            return (Criteria) this;
        }

        public Criteria and匝间标准值GreaterThan(String value) {
            addCriterion("匝间标准值 >", value, "匝间标准值");
            return (Criteria) this;
        }

        public Criteria and匝间标准值GreaterThanOrEqualTo(String value) {
            addCriterion("匝间标准值 >=", value, "匝间标准值");
            return (Criteria) this;
        }

        public Criteria and匝间标准值LessThan(String value) {
            addCriterion("匝间标准值 <", value, "匝间标准值");
            return (Criteria) this;
        }

        public Criteria and匝间标准值LessThanOrEqualTo(String value) {
            addCriterion("匝间标准值 <=", value, "匝间标准值");
            return (Criteria) this;
        }

        public Criteria and匝间标准值Like(String value) {
            addCriterion("匝间标准值 like", value, "匝间标准值");
            return (Criteria) this;
        }

        public Criteria and匝间标准值NotLike(String value) {
            addCriterion("匝间标准值 not like", value, "匝间标准值");
            return (Criteria) this;
        }

        public Criteria and匝间标准值In(List<String> values) {
            addCriterion("匝间标准值 in", values, "匝间标准值");
            return (Criteria) this;
        }

        public Criteria and匝间标准值NotIn(List<String> values) {
            addCriterion("匝间标准值 not in", values, "匝间标准值");
            return (Criteria) this;
        }

        public Criteria and匝间标准值Between(String value1, String value2) {
            addCriterion("匝间标准值 between", value1, value2, "匝间标准值");
            return (Criteria) this;
        }

        public Criteria and匝间标准值NotBetween(String value1, String value2) {
            addCriterion("匝间标准值 not between", value1, value2, "匝间标准值");
            return (Criteria) this;
        }

        public Criteria and匝间测试值IsNull() {
            addCriterion("匝间测试值 is null");
            return (Criteria) this;
        }

        public Criteria and匝间测试值IsNotNull() {
            addCriterion("匝间测试值 is not null");
            return (Criteria) this;
        }

        public Criteria and匝间测试值EqualTo(String value) {
            addCriterion("匝间测试值 =", value, "匝间测试值");
            return (Criteria) this;
        }

        public Criteria and匝间测试值NotEqualTo(String value) {
            addCriterion("匝间测试值 <>", value, "匝间测试值");
            return (Criteria) this;
        }

        public Criteria and匝间测试值GreaterThan(String value) {
            addCriterion("匝间测试值 >", value, "匝间测试值");
            return (Criteria) this;
        }

        public Criteria and匝间测试值GreaterThanOrEqualTo(String value) {
            addCriterion("匝间测试值 >=", value, "匝间测试值");
            return (Criteria) this;
        }

        public Criteria and匝间测试值LessThan(String value) {
            addCriterion("匝间测试值 <", value, "匝间测试值");
            return (Criteria) this;
        }

        public Criteria and匝间测试值LessThanOrEqualTo(String value) {
            addCriterion("匝间测试值 <=", value, "匝间测试值");
            return (Criteria) this;
        }

        public Criteria and匝间测试值Like(String value) {
            addCriterion("匝间测试值 like", value, "匝间测试值");
            return (Criteria) this;
        }

        public Criteria and匝间测试值NotLike(String value) {
            addCriterion("匝间测试值 not like", value, "匝间测试值");
            return (Criteria) this;
        }

        public Criteria and匝间测试值In(List<String> values) {
            addCriterion("匝间测试值 in", values, "匝间测试值");
            return (Criteria) this;
        }

        public Criteria and匝间测试值NotIn(List<String> values) {
            addCriterion("匝间测试值 not in", values, "匝间测试值");
            return (Criteria) this;
        }

        public Criteria and匝间测试值Between(String value1, String value2) {
            addCriterion("匝间测试值 between", value1, value2, "匝间测试值");
            return (Criteria) this;
        }

        public Criteria and匝间测试值NotBetween(String value1, String value2) {
            addCriterion("匝间测试值 not between", value1, value2, "匝间测试值");
            return (Criteria) this;
        }

        public Criteria and匝间测试结果IsNull() {
            addCriterion("匝间测试结果 is null");
            return (Criteria) this;
        }

        public Criteria and匝间测试结果IsNotNull() {
            addCriterion("匝间测试结果 is not null");
            return (Criteria) this;
        }

        public Criteria and匝间测试结果EqualTo(String value) {
            addCriterion("匝间测试结果 =", value, "匝间测试结果");
            return (Criteria) this;
        }

        public Criteria and匝间测试结果NotEqualTo(String value) {
            addCriterion("匝间测试结果 <>", value, "匝间测试结果");
            return (Criteria) this;
        }

        public Criteria and匝间测试结果GreaterThan(String value) {
            addCriterion("匝间测试结果 >", value, "匝间测试结果");
            return (Criteria) this;
        }

        public Criteria and匝间测试结果GreaterThanOrEqualTo(String value) {
            addCriterion("匝间测试结果 >=", value, "匝间测试结果");
            return (Criteria) this;
        }

        public Criteria and匝间测试结果LessThan(String value) {
            addCriterion("匝间测试结果 <", value, "匝间测试结果");
            return (Criteria) this;
        }

        public Criteria and匝间测试结果LessThanOrEqualTo(String value) {
            addCriterion("匝间测试结果 <=", value, "匝间测试结果");
            return (Criteria) this;
        }

        public Criteria and匝间测试结果Like(String value) {
            addCriterion("匝间测试结果 like", value, "匝间测试结果");
            return (Criteria) this;
        }

        public Criteria and匝间测试结果NotLike(String value) {
            addCriterion("匝间测试结果 not like", value, "匝间测试结果");
            return (Criteria) this;
        }

        public Criteria and匝间测试结果In(List<String> values) {
            addCriterion("匝间测试结果 in", values, "匝间测试结果");
            return (Criteria) this;
        }

        public Criteria and匝间测试结果NotIn(List<String> values) {
            addCriterion("匝间测试结果 not in", values, "匝间测试结果");
            return (Criteria) this;
        }

        public Criteria and匝间测试结果Between(String value1, String value2) {
            addCriterion("匝间测试结果 between", value1, value2, "匝间测试结果");
            return (Criteria) this;
        }

        public Criteria and匝间测试结果NotBetween(String value1, String value2) {
            addCriterion("匝间测试结果 not between", value1, value2, "匝间测试结果");
            return (Criteria) this;
        }

        public Criteria and堵转电压标准值IsNull() {
            addCriterion("堵转电压标准值 is null");
            return (Criteria) this;
        }

        public Criteria and堵转电压标准值IsNotNull() {
            addCriterion("堵转电压标准值 is not null");
            return (Criteria) this;
        }

        public Criteria and堵转电压标准值EqualTo(String value) {
            addCriterion("堵转电压标准值 =", value, "堵转电压标准值");
            return (Criteria) this;
        }

        public Criteria and堵转电压标准值NotEqualTo(String value) {
            addCriterion("堵转电压标准值 <>", value, "堵转电压标准值");
            return (Criteria) this;
        }

        public Criteria and堵转电压标准值GreaterThan(String value) {
            addCriterion("堵转电压标准值 >", value, "堵转电压标准值");
            return (Criteria) this;
        }

        public Criteria and堵转电压标准值GreaterThanOrEqualTo(String value) {
            addCriterion("堵转电压标准值 >=", value, "堵转电压标准值");
            return (Criteria) this;
        }

        public Criteria and堵转电压标准值LessThan(String value) {
            addCriterion("堵转电压标准值 <", value, "堵转电压标准值");
            return (Criteria) this;
        }

        public Criteria and堵转电压标准值LessThanOrEqualTo(String value) {
            addCriterion("堵转电压标准值 <=", value, "堵转电压标准值");
            return (Criteria) this;
        }

        public Criteria and堵转电压标准值Like(String value) {
            addCriterion("堵转电压标准值 like", value, "堵转电压标准值");
            return (Criteria) this;
        }

        public Criteria and堵转电压标准值NotLike(String value) {
            addCriterion("堵转电压标准值 not like", value, "堵转电压标准值");
            return (Criteria) this;
        }

        public Criteria and堵转电压标准值In(List<String> values) {
            addCriterion("堵转电压标准值 in", values, "堵转电压标准值");
            return (Criteria) this;
        }

        public Criteria and堵转电压标准值NotIn(List<String> values) {
            addCriterion("堵转电压标准值 not in", values, "堵转电压标准值");
            return (Criteria) this;
        }

        public Criteria and堵转电压标准值Between(String value1, String value2) {
            addCriterion("堵转电压标准值 between", value1, value2, "堵转电压标准值");
            return (Criteria) this;
        }

        public Criteria and堵转电压标准值NotBetween(String value1, String value2) {
            addCriterion("堵转电压标准值 not between", value1, value2, "堵转电压标准值");
            return (Criteria) this;
        }

        public Criteria and堵转实测电压IsNull() {
            addCriterion("堵转实测电压 is null");
            return (Criteria) this;
        }

        public Criteria and堵转实测电压IsNotNull() {
            addCriterion("堵转实测电压 is not null");
            return (Criteria) this;
        }

        public Criteria and堵转实测电压EqualTo(String value) {
            addCriterion("堵转实测电压 =", value, "堵转实测电压");
            return (Criteria) this;
        }

        public Criteria and堵转实测电压NotEqualTo(String value) {
            addCriterion("堵转实测电压 <>", value, "堵转实测电压");
            return (Criteria) this;
        }

        public Criteria and堵转实测电压GreaterThan(String value) {
            addCriterion("堵转实测电压 >", value, "堵转实测电压");
            return (Criteria) this;
        }

        public Criteria and堵转实测电压GreaterThanOrEqualTo(String value) {
            addCriterion("堵转实测电压 >=", value, "堵转实测电压");
            return (Criteria) this;
        }

        public Criteria and堵转实测电压LessThan(String value) {
            addCriterion("堵转实测电压 <", value, "堵转实测电压");
            return (Criteria) this;
        }

        public Criteria and堵转实测电压LessThanOrEqualTo(String value) {
            addCriterion("堵转实测电压 <=", value, "堵转实测电压");
            return (Criteria) this;
        }

        public Criteria and堵转实测电压Like(String value) {
            addCriterion("堵转实测电压 like", value, "堵转实测电压");
            return (Criteria) this;
        }

        public Criteria and堵转实测电压NotLike(String value) {
            addCriterion("堵转实测电压 not like", value, "堵转实测电压");
            return (Criteria) this;
        }

        public Criteria and堵转实测电压In(List<String> values) {
            addCriterion("堵转实测电压 in", values, "堵转实测电压");
            return (Criteria) this;
        }

        public Criteria and堵转实测电压NotIn(List<String> values) {
            addCriterion("堵转实测电压 not in", values, "堵转实测电压");
            return (Criteria) this;
        }

        public Criteria and堵转实测电压Between(String value1, String value2) {
            addCriterion("堵转实测电压 between", value1, value2, "堵转实测电压");
            return (Criteria) this;
        }

        public Criteria and堵转实测电压NotBetween(String value1, String value2) {
            addCriterion("堵转实测电压 not between", value1, value2, "堵转实测电压");
            return (Criteria) this;
        }

        public Criteria and堵转电流标准值IsNull() {
            addCriterion("堵转电流标准值 is null");
            return (Criteria) this;
        }

        public Criteria and堵转电流标准值IsNotNull() {
            addCriterion("堵转电流标准值 is not null");
            return (Criteria) this;
        }

        public Criteria and堵转电流标准值EqualTo(String value) {
            addCriterion("堵转电流标准值 =", value, "堵转电流标准值");
            return (Criteria) this;
        }

        public Criteria and堵转电流标准值NotEqualTo(String value) {
            addCriterion("堵转电流标准值 <>", value, "堵转电流标准值");
            return (Criteria) this;
        }

        public Criteria and堵转电流标准值GreaterThan(String value) {
            addCriterion("堵转电流标准值 >", value, "堵转电流标准值");
            return (Criteria) this;
        }

        public Criteria and堵转电流标准值GreaterThanOrEqualTo(String value) {
            addCriterion("堵转电流标准值 >=", value, "堵转电流标准值");
            return (Criteria) this;
        }

        public Criteria and堵转电流标准值LessThan(String value) {
            addCriterion("堵转电流标准值 <", value, "堵转电流标准值");
            return (Criteria) this;
        }

        public Criteria and堵转电流标准值LessThanOrEqualTo(String value) {
            addCriterion("堵转电流标准值 <=", value, "堵转电流标准值");
            return (Criteria) this;
        }

        public Criteria and堵转电流标准值Like(String value) {
            addCriterion("堵转电流标准值 like", value, "堵转电流标准值");
            return (Criteria) this;
        }

        public Criteria and堵转电流标准值NotLike(String value) {
            addCriterion("堵转电流标准值 not like", value, "堵转电流标准值");
            return (Criteria) this;
        }

        public Criteria and堵转电流标准值In(List<String> values) {
            addCriterion("堵转电流标准值 in", values, "堵转电流标准值");
            return (Criteria) this;
        }

        public Criteria and堵转电流标准值NotIn(List<String> values) {
            addCriterion("堵转电流标准值 not in", values, "堵转电流标准值");
            return (Criteria) this;
        }

        public Criteria and堵转电流标准值Between(String value1, String value2) {
            addCriterion("堵转电流标准值 between", value1, value2, "堵转电流标准值");
            return (Criteria) this;
        }

        public Criteria and堵转电流标准值NotBetween(String value1, String value2) {
            addCriterion("堵转电流标准值 not between", value1, value2, "堵转电流标准值");
            return (Criteria) this;
        }

        public Criteria and堵转电流实测值IsNull() {
            addCriterion("堵转电流实测值 is null");
            return (Criteria) this;
        }

        public Criteria and堵转电流实测值IsNotNull() {
            addCriterion("堵转电流实测值 is not null");
            return (Criteria) this;
        }

        public Criteria and堵转电流实测值EqualTo(String value) {
            addCriterion("堵转电流实测值 =", value, "堵转电流实测值");
            return (Criteria) this;
        }

        public Criteria and堵转电流实测值NotEqualTo(String value) {
            addCriterion("堵转电流实测值 <>", value, "堵转电流实测值");
            return (Criteria) this;
        }

        public Criteria and堵转电流实测值GreaterThan(String value) {
            addCriterion("堵转电流实测值 >", value, "堵转电流实测值");
            return (Criteria) this;
        }

        public Criteria and堵转电流实测值GreaterThanOrEqualTo(String value) {
            addCriterion("堵转电流实测值 >=", value, "堵转电流实测值");
            return (Criteria) this;
        }

        public Criteria and堵转电流实测值LessThan(String value) {
            addCriterion("堵转电流实测值 <", value, "堵转电流实测值");
            return (Criteria) this;
        }

        public Criteria and堵转电流实测值LessThanOrEqualTo(String value) {
            addCriterion("堵转电流实测值 <=", value, "堵转电流实测值");
            return (Criteria) this;
        }

        public Criteria and堵转电流实测值Like(String value) {
            addCriterion("堵转电流实测值 like", value, "堵转电流实测值");
            return (Criteria) this;
        }

        public Criteria and堵转电流实测值NotLike(String value) {
            addCriterion("堵转电流实测值 not like", value, "堵转电流实测值");
            return (Criteria) this;
        }

        public Criteria and堵转电流实测值In(List<String> values) {
            addCriterion("堵转电流实测值 in", values, "堵转电流实测值");
            return (Criteria) this;
        }

        public Criteria and堵转电流实测值NotIn(List<String> values) {
            addCriterion("堵转电流实测值 not in", values, "堵转电流实测值");
            return (Criteria) this;
        }

        public Criteria and堵转电流实测值Between(String value1, String value2) {
            addCriterion("堵转电流实测值 between", value1, value2, "堵转电流实测值");
            return (Criteria) this;
        }

        public Criteria and堵转电流实测值NotBetween(String value1, String value2) {
            addCriterion("堵转电流实测值 not between", value1, value2, "堵转电流实测值");
            return (Criteria) this;
        }

        public Criteria and堵转电流测试结果IsNull() {
            addCriterion("堵转电流测试结果 is null");
            return (Criteria) this;
        }

        public Criteria and堵转电流测试结果IsNotNull() {
            addCriterion("堵转电流测试结果 is not null");
            return (Criteria) this;
        }

        public Criteria and堵转电流测试结果EqualTo(String value) {
            addCriterion("堵转电流测试结果 =", value, "堵转电流测试结果");
            return (Criteria) this;
        }

        public Criteria and堵转电流测试结果NotEqualTo(String value) {
            addCriterion("堵转电流测试结果 <>", value, "堵转电流测试结果");
            return (Criteria) this;
        }

        public Criteria and堵转电流测试结果GreaterThan(String value) {
            addCriterion("堵转电流测试结果 >", value, "堵转电流测试结果");
            return (Criteria) this;
        }

        public Criteria and堵转电流测试结果GreaterThanOrEqualTo(String value) {
            addCriterion("堵转电流测试结果 >=", value, "堵转电流测试结果");
            return (Criteria) this;
        }

        public Criteria and堵转电流测试结果LessThan(String value) {
            addCriterion("堵转电流测试结果 <", value, "堵转电流测试结果");
            return (Criteria) this;
        }

        public Criteria and堵转电流测试结果LessThanOrEqualTo(String value) {
            addCriterion("堵转电流测试结果 <=", value, "堵转电流测试结果");
            return (Criteria) this;
        }

        public Criteria and堵转电流测试结果Like(String value) {
            addCriterion("堵转电流测试结果 like", value, "堵转电流测试结果");
            return (Criteria) this;
        }

        public Criteria and堵转电流测试结果NotLike(String value) {
            addCriterion("堵转电流测试结果 not like", value, "堵转电流测试结果");
            return (Criteria) this;
        }

        public Criteria and堵转电流测试结果In(List<String> values) {
            addCriterion("堵转电流测试结果 in", values, "堵转电流测试结果");
            return (Criteria) this;
        }

        public Criteria and堵转电流测试结果NotIn(List<String> values) {
            addCriterion("堵转电流测试结果 not in", values, "堵转电流测试结果");
            return (Criteria) this;
        }

        public Criteria and堵转电流测试结果Between(String value1, String value2) {
            addCriterion("堵转电流测试结果 between", value1, value2, "堵转电流测试结果");
            return (Criteria) this;
        }

        public Criteria and堵转电流测试结果NotBetween(String value1, String value2) {
            addCriterion("堵转电流测试结果 not between", value1, value2, "堵转电流测试结果");
            return (Criteria) this;
        }

        public Criteria and堵转电流平衡度标准值IsNull() {
            addCriterion("堵转电流平衡度标准值 is null");
            return (Criteria) this;
        }

        public Criteria and堵转电流平衡度标准值IsNotNull() {
            addCriterion("堵转电流平衡度标准值 is not null");
            return (Criteria) this;
        }

        public Criteria and堵转电流平衡度标准值EqualTo(String value) {
            addCriterion("堵转电流平衡度标准值 =", value, "堵转电流平衡度标准值");
            return (Criteria) this;
        }

        public Criteria and堵转电流平衡度标准值NotEqualTo(String value) {
            addCriterion("堵转电流平衡度标准值 <>", value, "堵转电流平衡度标准值");
            return (Criteria) this;
        }

        public Criteria and堵转电流平衡度标准值GreaterThan(String value) {
            addCriterion("堵转电流平衡度标准值 >", value, "堵转电流平衡度标准值");
            return (Criteria) this;
        }

        public Criteria and堵转电流平衡度标准值GreaterThanOrEqualTo(String value) {
            addCriterion("堵转电流平衡度标准值 >=", value, "堵转电流平衡度标准值");
            return (Criteria) this;
        }

        public Criteria and堵转电流平衡度标准值LessThan(String value) {
            addCriterion("堵转电流平衡度标准值 <", value, "堵转电流平衡度标准值");
            return (Criteria) this;
        }

        public Criteria and堵转电流平衡度标准值LessThanOrEqualTo(String value) {
            addCriterion("堵转电流平衡度标准值 <=", value, "堵转电流平衡度标准值");
            return (Criteria) this;
        }

        public Criteria and堵转电流平衡度标准值Like(String value) {
            addCriterion("堵转电流平衡度标准值 like", value, "堵转电流平衡度标准值");
            return (Criteria) this;
        }

        public Criteria and堵转电流平衡度标准值NotLike(String value) {
            addCriterion("堵转电流平衡度标准值 not like", value, "堵转电流平衡度标准值");
            return (Criteria) this;
        }

        public Criteria and堵转电流平衡度标准值In(List<String> values) {
            addCriterion("堵转电流平衡度标准值 in", values, "堵转电流平衡度标准值");
            return (Criteria) this;
        }

        public Criteria and堵转电流平衡度标准值NotIn(List<String> values) {
            addCriterion("堵转电流平衡度标准值 not in", values, "堵转电流平衡度标准值");
            return (Criteria) this;
        }

        public Criteria and堵转电流平衡度标准值Between(String value1, String value2) {
            addCriterion("堵转电流平衡度标准值 between", value1, value2, "堵转电流平衡度标准值");
            return (Criteria) this;
        }

        public Criteria and堵转电流平衡度标准值NotBetween(String value1, String value2) {
            addCriterion("堵转电流平衡度标准值 not between", value1, value2, "堵转电流平衡度标准值");
            return (Criteria) this;
        }

        public Criteria and堵转电流平衡度实测值IsNull() {
            addCriterion("堵转电流平衡度实测值 is null");
            return (Criteria) this;
        }

        public Criteria and堵转电流平衡度实测值IsNotNull() {
            addCriterion("堵转电流平衡度实测值 is not null");
            return (Criteria) this;
        }

        public Criteria and堵转电流平衡度实测值EqualTo(String value) {
            addCriterion("堵转电流平衡度实测值 =", value, "堵转电流平衡度实测值");
            return (Criteria) this;
        }

        public Criteria and堵转电流平衡度实测值NotEqualTo(String value) {
            addCriterion("堵转电流平衡度实测值 <>", value, "堵转电流平衡度实测值");
            return (Criteria) this;
        }

        public Criteria and堵转电流平衡度实测值GreaterThan(String value) {
            addCriterion("堵转电流平衡度实测值 >", value, "堵转电流平衡度实测值");
            return (Criteria) this;
        }

        public Criteria and堵转电流平衡度实测值GreaterThanOrEqualTo(String value) {
            addCriterion("堵转电流平衡度实测值 >=", value, "堵转电流平衡度实测值");
            return (Criteria) this;
        }

        public Criteria and堵转电流平衡度实测值LessThan(String value) {
            addCriterion("堵转电流平衡度实测值 <", value, "堵转电流平衡度实测值");
            return (Criteria) this;
        }

        public Criteria and堵转电流平衡度实测值LessThanOrEqualTo(String value) {
            addCriterion("堵转电流平衡度实测值 <=", value, "堵转电流平衡度实测值");
            return (Criteria) this;
        }

        public Criteria and堵转电流平衡度实测值Like(String value) {
            addCriterion("堵转电流平衡度实测值 like", value, "堵转电流平衡度实测值");
            return (Criteria) this;
        }

        public Criteria and堵转电流平衡度实测值NotLike(String value) {
            addCriterion("堵转电流平衡度实测值 not like", value, "堵转电流平衡度实测值");
            return (Criteria) this;
        }

        public Criteria and堵转电流平衡度实测值In(List<String> values) {
            addCriterion("堵转电流平衡度实测值 in", values, "堵转电流平衡度实测值");
            return (Criteria) this;
        }

        public Criteria and堵转电流平衡度实测值NotIn(List<String> values) {
            addCriterion("堵转电流平衡度实测值 not in", values, "堵转电流平衡度实测值");
            return (Criteria) this;
        }

        public Criteria and堵转电流平衡度实测值Between(String value1, String value2) {
            addCriterion("堵转电流平衡度实测值 between", value1, value2, "堵转电流平衡度实测值");
            return (Criteria) this;
        }

        public Criteria and堵转电流平衡度实测值NotBetween(String value1, String value2) {
            addCriterion("堵转电流平衡度实测值 not between", value1, value2, "堵转电流平衡度实测值");
            return (Criteria) this;
        }

        public Criteria and堵转电流平衡度测试结果IsNull() {
            addCriterion("堵转电流平衡度测试结果 is null");
            return (Criteria) this;
        }

        public Criteria and堵转电流平衡度测试结果IsNotNull() {
            addCriterion("堵转电流平衡度测试结果 is not null");
            return (Criteria) this;
        }

        public Criteria and堵转电流平衡度测试结果EqualTo(String value) {
            addCriterion("堵转电流平衡度测试结果 =", value, "堵转电流平衡度测试结果");
            return (Criteria) this;
        }

        public Criteria and堵转电流平衡度测试结果NotEqualTo(String value) {
            addCriterion("堵转电流平衡度测试结果 <>", value, "堵转电流平衡度测试结果");
            return (Criteria) this;
        }

        public Criteria and堵转电流平衡度测试结果GreaterThan(String value) {
            addCriterion("堵转电流平衡度测试结果 >", value, "堵转电流平衡度测试结果");
            return (Criteria) this;
        }

        public Criteria and堵转电流平衡度测试结果GreaterThanOrEqualTo(String value) {
            addCriterion("堵转电流平衡度测试结果 >=", value, "堵转电流平衡度测试结果");
            return (Criteria) this;
        }

        public Criteria and堵转电流平衡度测试结果LessThan(String value) {
            addCriterion("堵转电流平衡度测试结果 <", value, "堵转电流平衡度测试结果");
            return (Criteria) this;
        }

        public Criteria and堵转电流平衡度测试结果LessThanOrEqualTo(String value) {
            addCriterion("堵转电流平衡度测试结果 <=", value, "堵转电流平衡度测试结果");
            return (Criteria) this;
        }

        public Criteria and堵转电流平衡度测试结果Like(String value) {
            addCriterion("堵转电流平衡度测试结果 like", value, "堵转电流平衡度测试结果");
            return (Criteria) this;
        }

        public Criteria and堵转电流平衡度测试结果NotLike(String value) {
            addCriterion("堵转电流平衡度测试结果 not like", value, "堵转电流平衡度测试结果");
            return (Criteria) this;
        }

        public Criteria and堵转电流平衡度测试结果In(List<String> values) {
            addCriterion("堵转电流平衡度测试结果 in", values, "堵转电流平衡度测试结果");
            return (Criteria) this;
        }

        public Criteria and堵转电流平衡度测试结果NotIn(List<String> values) {
            addCriterion("堵转电流平衡度测试结果 not in", values, "堵转电流平衡度测试结果");
            return (Criteria) this;
        }

        public Criteria and堵转电流平衡度测试结果Between(String value1, String value2) {
            addCriterion("堵转电流平衡度测试结果 between", value1, value2, "堵转电流平衡度测试结果");
            return (Criteria) this;
        }

        public Criteria and堵转电流平衡度测试结果NotBetween(String value1, String value2) {
            addCriterion("堵转电流平衡度测试结果 not between", value1, value2, "堵转电流平衡度测试结果");
            return (Criteria) this;
        }

        public Criteria and堵转功率标准值IsNull() {
            addCriterion("堵转功率标准值 is null");
            return (Criteria) this;
        }

        public Criteria and堵转功率标准值IsNotNull() {
            addCriterion("堵转功率标准值 is not null");
            return (Criteria) this;
        }

        public Criteria and堵转功率标准值EqualTo(String value) {
            addCriterion("堵转功率标准值 =", value, "堵转功率标准值");
            return (Criteria) this;
        }

        public Criteria and堵转功率标准值NotEqualTo(String value) {
            addCriterion("堵转功率标准值 <>", value, "堵转功率标准值");
            return (Criteria) this;
        }

        public Criteria and堵转功率标准值GreaterThan(String value) {
            addCriterion("堵转功率标准值 >", value, "堵转功率标准值");
            return (Criteria) this;
        }

        public Criteria and堵转功率标准值GreaterThanOrEqualTo(String value) {
            addCriterion("堵转功率标准值 >=", value, "堵转功率标准值");
            return (Criteria) this;
        }

        public Criteria and堵转功率标准值LessThan(String value) {
            addCriterion("堵转功率标准值 <", value, "堵转功率标准值");
            return (Criteria) this;
        }

        public Criteria and堵转功率标准值LessThanOrEqualTo(String value) {
            addCriterion("堵转功率标准值 <=", value, "堵转功率标准值");
            return (Criteria) this;
        }

        public Criteria and堵转功率标准值Like(String value) {
            addCriterion("堵转功率标准值 like", value, "堵转功率标准值");
            return (Criteria) this;
        }

        public Criteria and堵转功率标准值NotLike(String value) {
            addCriterion("堵转功率标准值 not like", value, "堵转功率标准值");
            return (Criteria) this;
        }

        public Criteria and堵转功率标准值In(List<String> values) {
            addCriterion("堵转功率标准值 in", values, "堵转功率标准值");
            return (Criteria) this;
        }

        public Criteria and堵转功率标准值NotIn(List<String> values) {
            addCriterion("堵转功率标准值 not in", values, "堵转功率标准值");
            return (Criteria) this;
        }

        public Criteria and堵转功率标准值Between(String value1, String value2) {
            addCriterion("堵转功率标准值 between", value1, value2, "堵转功率标准值");
            return (Criteria) this;
        }

        public Criteria and堵转功率标准值NotBetween(String value1, String value2) {
            addCriterion("堵转功率标准值 not between", value1, value2, "堵转功率标准值");
            return (Criteria) this;
        }

        public Criteria and堵转功率实测值IsNull() {
            addCriterion("堵转功率实测值 is null");
            return (Criteria) this;
        }

        public Criteria and堵转功率实测值IsNotNull() {
            addCriterion("堵转功率实测值 is not null");
            return (Criteria) this;
        }

        public Criteria and堵转功率实测值EqualTo(String value) {
            addCriterion("堵转功率实测值 =", value, "堵转功率实测值");
            return (Criteria) this;
        }

        public Criteria and堵转功率实测值NotEqualTo(String value) {
            addCriterion("堵转功率实测值 <>", value, "堵转功率实测值");
            return (Criteria) this;
        }

        public Criteria and堵转功率实测值GreaterThan(String value) {
            addCriterion("堵转功率实测值 >", value, "堵转功率实测值");
            return (Criteria) this;
        }

        public Criteria and堵转功率实测值GreaterThanOrEqualTo(String value) {
            addCriterion("堵转功率实测值 >=", value, "堵转功率实测值");
            return (Criteria) this;
        }

        public Criteria and堵转功率实测值LessThan(String value) {
            addCriterion("堵转功率实测值 <", value, "堵转功率实测值");
            return (Criteria) this;
        }

        public Criteria and堵转功率实测值LessThanOrEqualTo(String value) {
            addCriterion("堵转功率实测值 <=", value, "堵转功率实测值");
            return (Criteria) this;
        }

        public Criteria and堵转功率实测值Like(String value) {
            addCriterion("堵转功率实测值 like", value, "堵转功率实测值");
            return (Criteria) this;
        }

        public Criteria and堵转功率实测值NotLike(String value) {
            addCriterion("堵转功率实测值 not like", value, "堵转功率实测值");
            return (Criteria) this;
        }

        public Criteria and堵转功率实测值In(List<String> values) {
            addCriterion("堵转功率实测值 in", values, "堵转功率实测值");
            return (Criteria) this;
        }

        public Criteria and堵转功率实测值NotIn(List<String> values) {
            addCriterion("堵转功率实测值 not in", values, "堵转功率实测值");
            return (Criteria) this;
        }

        public Criteria and堵转功率实测值Between(String value1, String value2) {
            addCriterion("堵转功率实测值 between", value1, value2, "堵转功率实测值");
            return (Criteria) this;
        }

        public Criteria and堵转功率实测值NotBetween(String value1, String value2) {
            addCriterion("堵转功率实测值 not between", value1, value2, "堵转功率实测值");
            return (Criteria) this;
        }

        public Criteria and堵转功率测试结果IsNull() {
            addCriterion("堵转功率测试结果 is null");
            return (Criteria) this;
        }

        public Criteria and堵转功率测试结果IsNotNull() {
            addCriterion("堵转功率测试结果 is not null");
            return (Criteria) this;
        }

        public Criteria and堵转功率测试结果EqualTo(String value) {
            addCriterion("堵转功率测试结果 =", value, "堵转功率测试结果");
            return (Criteria) this;
        }

        public Criteria and堵转功率测试结果NotEqualTo(String value) {
            addCriterion("堵转功率测试结果 <>", value, "堵转功率测试结果");
            return (Criteria) this;
        }

        public Criteria and堵转功率测试结果GreaterThan(String value) {
            addCriterion("堵转功率测试结果 >", value, "堵转功率测试结果");
            return (Criteria) this;
        }

        public Criteria and堵转功率测试结果GreaterThanOrEqualTo(String value) {
            addCriterion("堵转功率测试结果 >=", value, "堵转功率测试结果");
            return (Criteria) this;
        }

        public Criteria and堵转功率测试结果LessThan(String value) {
            addCriterion("堵转功率测试结果 <", value, "堵转功率测试结果");
            return (Criteria) this;
        }

        public Criteria and堵转功率测试结果LessThanOrEqualTo(String value) {
            addCriterion("堵转功率测试结果 <=", value, "堵转功率测试结果");
            return (Criteria) this;
        }

        public Criteria and堵转功率测试结果Like(String value) {
            addCriterion("堵转功率测试结果 like", value, "堵转功率测试结果");
            return (Criteria) this;
        }

        public Criteria and堵转功率测试结果NotLike(String value) {
            addCriterion("堵转功率测试结果 not like", value, "堵转功率测试结果");
            return (Criteria) this;
        }

        public Criteria and堵转功率测试结果In(List<String> values) {
            addCriterion("堵转功率测试结果 in", values, "堵转功率测试结果");
            return (Criteria) this;
        }

        public Criteria and堵转功率测试结果NotIn(List<String> values) {
            addCriterion("堵转功率测试结果 not in", values, "堵转功率测试结果");
            return (Criteria) this;
        }

        public Criteria and堵转功率测试结果Between(String value1, String value2) {
            addCriterion("堵转功率测试结果 between", value1, value2, "堵转功率测试结果");
            return (Criteria) this;
        }

        public Criteria and堵转功率测试结果NotBetween(String value1, String value2) {
            addCriterion("堵转功率测试结果 not between", value1, value2, "堵转功率测试结果");
            return (Criteria) this;
        }

        public Criteria and空载电压标准值IsNull() {
            addCriterion("空载电压标准值 is null");
            return (Criteria) this;
        }

        public Criteria and空载电压标准值IsNotNull() {
            addCriterion("空载电压标准值 is not null");
            return (Criteria) this;
        }

        public Criteria and空载电压标准值EqualTo(Double value) {
            addCriterion("空载电压标准值 =", value, "空载电压标准值");
            return (Criteria) this;
        }

        public Criteria and空载电压标准值NotEqualTo(Double value) {
            addCriterion("空载电压标准值 <>", value, "空载电压标准值");
            return (Criteria) this;
        }

        public Criteria and空载电压标准值GreaterThan(Double value) {
            addCriterion("空载电压标准值 >", value, "空载电压标准值");
            return (Criteria) this;
        }

        public Criteria and空载电压标准值GreaterThanOrEqualTo(Double value) {
            addCriterion("空载电压标准值 >=", value, "空载电压标准值");
            return (Criteria) this;
        }

        public Criteria and空载电压标准值LessThan(Double value) {
            addCriterion("空载电压标准值 <", value, "空载电压标准值");
            return (Criteria) this;
        }

        public Criteria and空载电压标准值LessThanOrEqualTo(Double value) {
            addCriterion("空载电压标准值 <=", value, "空载电压标准值");
            return (Criteria) this;
        }

        public Criteria and空载电压标准值In(List<Double> values) {
            addCriterion("空载电压标准值 in", values, "空载电压标准值");
            return (Criteria) this;
        }

        public Criteria and空载电压标准值NotIn(List<Double> values) {
            addCriterion("空载电压标准值 not in", values, "空载电压标准值");
            return (Criteria) this;
        }

        public Criteria and空载电压标准值Between(Double value1, Double value2) {
            addCriterion("空载电压标准值 between", value1, value2, "空载电压标准值");
            return (Criteria) this;
        }

        public Criteria and空载电压标准值NotBetween(Double value1, Double value2) {
            addCriterion("空载电压标准值 not between", value1, value2, "空载电压标准值");
            return (Criteria) this;
        }

        public Criteria and空载实测电压IsNull() {
            addCriterion("空载实测电压 is null");
            return (Criteria) this;
        }

        public Criteria and空载实测电压IsNotNull() {
            addCriterion("空载实测电压 is not null");
            return (Criteria) this;
        }

        public Criteria and空载实测电压EqualTo(String value) {
            addCriterion("空载实测电压 =", value, "空载实测电压");
            return (Criteria) this;
        }

        public Criteria and空载实测电压NotEqualTo(String value) {
            addCriterion("空载实测电压 <>", value, "空载实测电压");
            return (Criteria) this;
        }

        public Criteria and空载实测电压GreaterThan(String value) {
            addCriterion("空载实测电压 >", value, "空载实测电压");
            return (Criteria) this;
        }

        public Criteria and空载实测电压GreaterThanOrEqualTo(String value) {
            addCriterion("空载实测电压 >=", value, "空载实测电压");
            return (Criteria) this;
        }

        public Criteria and空载实测电压LessThan(String value) {
            addCriterion("空载实测电压 <", value, "空载实测电压");
            return (Criteria) this;
        }

        public Criteria and空载实测电压LessThanOrEqualTo(String value) {
            addCriterion("空载实测电压 <=", value, "空载实测电压");
            return (Criteria) this;
        }

        public Criteria and空载实测电压Like(String value) {
            addCriterion("空载实测电压 like", value, "空载实测电压");
            return (Criteria) this;
        }

        public Criteria and空载实测电压NotLike(String value) {
            addCriterion("空载实测电压 not like", value, "空载实测电压");
            return (Criteria) this;
        }

        public Criteria and空载实测电压In(List<String> values) {
            addCriterion("空载实测电压 in", values, "空载实测电压");
            return (Criteria) this;
        }

        public Criteria and空载实测电压NotIn(List<String> values) {
            addCriterion("空载实测电压 not in", values, "空载实测电压");
            return (Criteria) this;
        }

        public Criteria and空载实测电压Between(String value1, String value2) {
            addCriterion("空载实测电压 between", value1, value2, "空载实测电压");
            return (Criteria) this;
        }

        public Criteria and空载实测电压NotBetween(String value1, String value2) {
            addCriterion("空载实测电压 not between", value1, value2, "空载实测电压");
            return (Criteria) this;
        }

        public Criteria and空载电流标准值IsNull() {
            addCriterion("空载电流标准值 is null");
            return (Criteria) this;
        }

        public Criteria and空载电流标准值IsNotNull() {
            addCriterion("空载电流标准值 is not null");
            return (Criteria) this;
        }

        public Criteria and空载电流标准值EqualTo(String value) {
            addCriterion("空载电流标准值 =", value, "空载电流标准值");
            return (Criteria) this;
        }

        public Criteria and空载电流标准值NotEqualTo(String value) {
            addCriterion("空载电流标准值 <>", value, "空载电流标准值");
            return (Criteria) this;
        }

        public Criteria and空载电流标准值GreaterThan(String value) {
            addCriterion("空载电流标准值 >", value, "空载电流标准值");
            return (Criteria) this;
        }

        public Criteria and空载电流标准值GreaterThanOrEqualTo(String value) {
            addCriterion("空载电流标准值 >=", value, "空载电流标准值");
            return (Criteria) this;
        }

        public Criteria and空载电流标准值LessThan(String value) {
            addCriterion("空载电流标准值 <", value, "空载电流标准值");
            return (Criteria) this;
        }

        public Criteria and空载电流标准值LessThanOrEqualTo(String value) {
            addCriterion("空载电流标准值 <=", value, "空载电流标准值");
            return (Criteria) this;
        }

        public Criteria and空载电流标准值Like(String value) {
            addCriterion("空载电流标准值 like", value, "空载电流标准值");
            return (Criteria) this;
        }

        public Criteria and空载电流标准值NotLike(String value) {
            addCriterion("空载电流标准值 not like", value, "空载电流标准值");
            return (Criteria) this;
        }

        public Criteria and空载电流标准值In(List<String> values) {
            addCriterion("空载电流标准值 in", values, "空载电流标准值");
            return (Criteria) this;
        }

        public Criteria and空载电流标准值NotIn(List<String> values) {
            addCriterion("空载电流标准值 not in", values, "空载电流标准值");
            return (Criteria) this;
        }

        public Criteria and空载电流标准值Between(String value1, String value2) {
            addCriterion("空载电流标准值 between", value1, value2, "空载电流标准值");
            return (Criteria) this;
        }

        public Criteria and空载电流标准值NotBetween(String value1, String value2) {
            addCriterion("空载电流标准值 not between", value1, value2, "空载电流标准值");
            return (Criteria) this;
        }

        public Criteria and空载电流实测值IsNull() {
            addCriterion("空载电流实测值 is null");
            return (Criteria) this;
        }

        public Criteria and空载电流实测值IsNotNull() {
            addCriterion("空载电流实测值 is not null");
            return (Criteria) this;
        }

        public Criteria and空载电流实测值EqualTo(String value) {
            addCriterion("空载电流实测值 =", value, "空载电流实测值");
            return (Criteria) this;
        }

        public Criteria and空载电流实测值NotEqualTo(String value) {
            addCriterion("空载电流实测值 <>", value, "空载电流实测值");
            return (Criteria) this;
        }

        public Criteria and空载电流实测值GreaterThan(String value) {
            addCriterion("空载电流实测值 >", value, "空载电流实测值");
            return (Criteria) this;
        }

        public Criteria and空载电流实测值GreaterThanOrEqualTo(String value) {
            addCriterion("空载电流实测值 >=", value, "空载电流实测值");
            return (Criteria) this;
        }

        public Criteria and空载电流实测值LessThan(String value) {
            addCriterion("空载电流实测值 <", value, "空载电流实测值");
            return (Criteria) this;
        }

        public Criteria and空载电流实测值LessThanOrEqualTo(String value) {
            addCriterion("空载电流实测值 <=", value, "空载电流实测值");
            return (Criteria) this;
        }

        public Criteria and空载电流实测值Like(String value) {
            addCriterion("空载电流实测值 like", value, "空载电流实测值");
            return (Criteria) this;
        }

        public Criteria and空载电流实测值NotLike(String value) {
            addCriterion("空载电流实测值 not like", value, "空载电流实测值");
            return (Criteria) this;
        }

        public Criteria and空载电流实测值In(List<String> values) {
            addCriterion("空载电流实测值 in", values, "空载电流实测值");
            return (Criteria) this;
        }

        public Criteria and空载电流实测值NotIn(List<String> values) {
            addCriterion("空载电流实测值 not in", values, "空载电流实测值");
            return (Criteria) this;
        }

        public Criteria and空载电流实测值Between(String value1, String value2) {
            addCriterion("空载电流实测值 between", value1, value2, "空载电流实测值");
            return (Criteria) this;
        }

        public Criteria and空载电流实测值NotBetween(String value1, String value2) {
            addCriterion("空载电流实测值 not between", value1, value2, "空载电流实测值");
            return (Criteria) this;
        }

        public Criteria and空载电流测试结果IsNull() {
            addCriterion("空载电流测试结果 is null");
            return (Criteria) this;
        }

        public Criteria and空载电流测试结果IsNotNull() {
            addCriterion("空载电流测试结果 is not null");
            return (Criteria) this;
        }

        public Criteria and空载电流测试结果EqualTo(String value) {
            addCriterion("空载电流测试结果 =", value, "空载电流测试结果");
            return (Criteria) this;
        }

        public Criteria and空载电流测试结果NotEqualTo(String value) {
            addCriterion("空载电流测试结果 <>", value, "空载电流测试结果");
            return (Criteria) this;
        }

        public Criteria and空载电流测试结果GreaterThan(String value) {
            addCriterion("空载电流测试结果 >", value, "空载电流测试结果");
            return (Criteria) this;
        }

        public Criteria and空载电流测试结果GreaterThanOrEqualTo(String value) {
            addCriterion("空载电流测试结果 >=", value, "空载电流测试结果");
            return (Criteria) this;
        }

        public Criteria and空载电流测试结果LessThan(String value) {
            addCriterion("空载电流测试结果 <", value, "空载电流测试结果");
            return (Criteria) this;
        }

        public Criteria and空载电流测试结果LessThanOrEqualTo(String value) {
            addCriterion("空载电流测试结果 <=", value, "空载电流测试结果");
            return (Criteria) this;
        }

        public Criteria and空载电流测试结果Like(String value) {
            addCriterion("空载电流测试结果 like", value, "空载电流测试结果");
            return (Criteria) this;
        }

        public Criteria and空载电流测试结果NotLike(String value) {
            addCriterion("空载电流测试结果 not like", value, "空载电流测试结果");
            return (Criteria) this;
        }

        public Criteria and空载电流测试结果In(List<String> values) {
            addCriterion("空载电流测试结果 in", values, "空载电流测试结果");
            return (Criteria) this;
        }

        public Criteria and空载电流测试结果NotIn(List<String> values) {
            addCriterion("空载电流测试结果 not in", values, "空载电流测试结果");
            return (Criteria) this;
        }

        public Criteria and空载电流测试结果Between(String value1, String value2) {
            addCriterion("空载电流测试结果 between", value1, value2, "空载电流测试结果");
            return (Criteria) this;
        }

        public Criteria and空载电流测试结果NotBetween(String value1, String value2) {
            addCriterion("空载电流测试结果 not between", value1, value2, "空载电流测试结果");
            return (Criteria) this;
        }

        public Criteria and空载电流平衡度标准值IsNull() {
            addCriterion("空载电流平衡度标准值 is null");
            return (Criteria) this;
        }

        public Criteria and空载电流平衡度标准值IsNotNull() {
            addCriterion("空载电流平衡度标准值 is not null");
            return (Criteria) this;
        }

        public Criteria and空载电流平衡度标准值EqualTo(Double value) {
            addCriterion("空载电流平衡度标准值 =", value, "空载电流平衡度标准值");
            return (Criteria) this;
        }

        public Criteria and空载电流平衡度标准值NotEqualTo(Double value) {
            addCriterion("空载电流平衡度标准值 <>", value, "空载电流平衡度标准值");
            return (Criteria) this;
        }

        public Criteria and空载电流平衡度标准值GreaterThan(Double value) {
            addCriterion("空载电流平衡度标准值 >", value, "空载电流平衡度标准值");
            return (Criteria) this;
        }

        public Criteria and空载电流平衡度标准值GreaterThanOrEqualTo(Double value) {
            addCriterion("空载电流平衡度标准值 >=", value, "空载电流平衡度标准值");
            return (Criteria) this;
        }

        public Criteria and空载电流平衡度标准值LessThan(Double value) {
            addCriterion("空载电流平衡度标准值 <", value, "空载电流平衡度标准值");
            return (Criteria) this;
        }

        public Criteria and空载电流平衡度标准值LessThanOrEqualTo(Double value) {
            addCriterion("空载电流平衡度标准值 <=", value, "空载电流平衡度标准值");
            return (Criteria) this;
        }

        public Criteria and空载电流平衡度标准值In(List<Double> values) {
            addCriterion("空载电流平衡度标准值 in", values, "空载电流平衡度标准值");
            return (Criteria) this;
        }

        public Criteria and空载电流平衡度标准值NotIn(List<Double> values) {
            addCriterion("空载电流平衡度标准值 not in", values, "空载电流平衡度标准值");
            return (Criteria) this;
        }

        public Criteria and空载电流平衡度标准值Between(Double value1, Double value2) {
            addCriterion("空载电流平衡度标准值 between", value1, value2, "空载电流平衡度标准值");
            return (Criteria) this;
        }

        public Criteria and空载电流平衡度标准值NotBetween(Double value1, Double value2) {
            addCriterion("空载电流平衡度标准值 not between", value1, value2, "空载电流平衡度标准值");
            return (Criteria) this;
        }

        public Criteria and空载电流平衡度实测值IsNull() {
            addCriterion("空载电流平衡度实测值 is null");
            return (Criteria) this;
        }

        public Criteria and空载电流平衡度实测值IsNotNull() {
            addCriterion("空载电流平衡度实测值 is not null");
            return (Criteria) this;
        }

        public Criteria and空载电流平衡度实测值EqualTo(String value) {
            addCriterion("空载电流平衡度实测值 =", value, "空载电流平衡度实测值");
            return (Criteria) this;
        }

        public Criteria and空载电流平衡度实测值NotEqualTo(String value) {
            addCriterion("空载电流平衡度实测值 <>", value, "空载电流平衡度实测值");
            return (Criteria) this;
        }

        public Criteria and空载电流平衡度实测值GreaterThan(String value) {
            addCriterion("空载电流平衡度实测值 >", value, "空载电流平衡度实测值");
            return (Criteria) this;
        }

        public Criteria and空载电流平衡度实测值GreaterThanOrEqualTo(String value) {
            addCriterion("空载电流平衡度实测值 >=", value, "空载电流平衡度实测值");
            return (Criteria) this;
        }

        public Criteria and空载电流平衡度实测值LessThan(String value) {
            addCriterion("空载电流平衡度实测值 <", value, "空载电流平衡度实测值");
            return (Criteria) this;
        }

        public Criteria and空载电流平衡度实测值LessThanOrEqualTo(String value) {
            addCriterion("空载电流平衡度实测值 <=", value, "空载电流平衡度实测值");
            return (Criteria) this;
        }

        public Criteria and空载电流平衡度实测值Like(String value) {
            addCriterion("空载电流平衡度实测值 like", value, "空载电流平衡度实测值");
            return (Criteria) this;
        }

        public Criteria and空载电流平衡度实测值NotLike(String value) {
            addCriterion("空载电流平衡度实测值 not like", value, "空载电流平衡度实测值");
            return (Criteria) this;
        }

        public Criteria and空载电流平衡度实测值In(List<String> values) {
            addCriterion("空载电流平衡度实测值 in", values, "空载电流平衡度实测值");
            return (Criteria) this;
        }

        public Criteria and空载电流平衡度实测值NotIn(List<String> values) {
            addCriterion("空载电流平衡度实测值 not in", values, "空载电流平衡度实测值");
            return (Criteria) this;
        }

        public Criteria and空载电流平衡度实测值Between(String value1, String value2) {
            addCriterion("空载电流平衡度实测值 between", value1, value2, "空载电流平衡度实测值");
            return (Criteria) this;
        }

        public Criteria and空载电流平衡度实测值NotBetween(String value1, String value2) {
            addCriterion("空载电流平衡度实测值 not between", value1, value2, "空载电流平衡度实测值");
            return (Criteria) this;
        }

        public Criteria and空载电流平衡度测试结果IsNull() {
            addCriterion("空载电流平衡度测试结果 is null");
            return (Criteria) this;
        }

        public Criteria and空载电流平衡度测试结果IsNotNull() {
            addCriterion("空载电流平衡度测试结果 is not null");
            return (Criteria) this;
        }

        public Criteria and空载电流平衡度测试结果EqualTo(String value) {
            addCriterion("空载电流平衡度测试结果 =", value, "空载电流平衡度测试结果");
            return (Criteria) this;
        }

        public Criteria and空载电流平衡度测试结果NotEqualTo(String value) {
            addCriterion("空载电流平衡度测试结果 <>", value, "空载电流平衡度测试结果");
            return (Criteria) this;
        }

        public Criteria and空载电流平衡度测试结果GreaterThan(String value) {
            addCriterion("空载电流平衡度测试结果 >", value, "空载电流平衡度测试结果");
            return (Criteria) this;
        }

        public Criteria and空载电流平衡度测试结果GreaterThanOrEqualTo(String value) {
            addCriterion("空载电流平衡度测试结果 >=", value, "空载电流平衡度测试结果");
            return (Criteria) this;
        }

        public Criteria and空载电流平衡度测试结果LessThan(String value) {
            addCriterion("空载电流平衡度测试结果 <", value, "空载电流平衡度测试结果");
            return (Criteria) this;
        }

        public Criteria and空载电流平衡度测试结果LessThanOrEqualTo(String value) {
            addCriterion("空载电流平衡度测试结果 <=", value, "空载电流平衡度测试结果");
            return (Criteria) this;
        }

        public Criteria and空载电流平衡度测试结果Like(String value) {
            addCriterion("空载电流平衡度测试结果 like", value, "空载电流平衡度测试结果");
            return (Criteria) this;
        }

        public Criteria and空载电流平衡度测试结果NotLike(String value) {
            addCriterion("空载电流平衡度测试结果 not like", value, "空载电流平衡度测试结果");
            return (Criteria) this;
        }

        public Criteria and空载电流平衡度测试结果In(List<String> values) {
            addCriterion("空载电流平衡度测试结果 in", values, "空载电流平衡度测试结果");
            return (Criteria) this;
        }

        public Criteria and空载电流平衡度测试结果NotIn(List<String> values) {
            addCriterion("空载电流平衡度测试结果 not in", values, "空载电流平衡度测试结果");
            return (Criteria) this;
        }

        public Criteria and空载电流平衡度测试结果Between(String value1, String value2) {
            addCriterion("空载电流平衡度测试结果 between", value1, value2, "空载电流平衡度测试结果");
            return (Criteria) this;
        }

        public Criteria and空载电流平衡度测试结果NotBetween(String value1, String value2) {
            addCriterion("空载电流平衡度测试结果 not between", value1, value2, "空载电流平衡度测试结果");
            return (Criteria) this;
        }

        public Criteria and空载功率标准值IsNull() {
            addCriterion("空载功率标准值 is null");
            return (Criteria) this;
        }

        public Criteria and空载功率标准值IsNotNull() {
            addCriterion("空载功率标准值 is not null");
            return (Criteria) this;
        }

        public Criteria and空载功率标准值EqualTo(String value) {
            addCriterion("空载功率标准值 =", value, "空载功率标准值");
            return (Criteria) this;
        }

        public Criteria and空载功率标准值NotEqualTo(String value) {
            addCriterion("空载功率标准值 <>", value, "空载功率标准值");
            return (Criteria) this;
        }

        public Criteria and空载功率标准值GreaterThan(String value) {
            addCriterion("空载功率标准值 >", value, "空载功率标准值");
            return (Criteria) this;
        }

        public Criteria and空载功率标准值GreaterThanOrEqualTo(String value) {
            addCriterion("空载功率标准值 >=", value, "空载功率标准值");
            return (Criteria) this;
        }

        public Criteria and空载功率标准值LessThan(String value) {
            addCriterion("空载功率标准值 <", value, "空载功率标准值");
            return (Criteria) this;
        }

        public Criteria and空载功率标准值LessThanOrEqualTo(String value) {
            addCriterion("空载功率标准值 <=", value, "空载功率标准值");
            return (Criteria) this;
        }

        public Criteria and空载功率标准值Like(String value) {
            addCriterion("空载功率标准值 like", value, "空载功率标准值");
            return (Criteria) this;
        }

        public Criteria and空载功率标准值NotLike(String value) {
            addCriterion("空载功率标准值 not like", value, "空载功率标准值");
            return (Criteria) this;
        }

        public Criteria and空载功率标准值In(List<String> values) {
            addCriterion("空载功率标准值 in", values, "空载功率标准值");
            return (Criteria) this;
        }

        public Criteria and空载功率标准值NotIn(List<String> values) {
            addCriterion("空载功率标准值 not in", values, "空载功率标准值");
            return (Criteria) this;
        }

        public Criteria and空载功率标准值Between(String value1, String value2) {
            addCriterion("空载功率标准值 between", value1, value2, "空载功率标准值");
            return (Criteria) this;
        }

        public Criteria and空载功率标准值NotBetween(String value1, String value2) {
            addCriterion("空载功率标准值 not between", value1, value2, "空载功率标准值");
            return (Criteria) this;
        }

        public Criteria and空载功率实测值IsNull() {
            addCriterion("空载功率实测值 is null");
            return (Criteria) this;
        }

        public Criteria and空载功率实测值IsNotNull() {
            addCriterion("空载功率实测值 is not null");
            return (Criteria) this;
        }

        public Criteria and空载功率实测值EqualTo(String value) {
            addCriterion("空载功率实测值 =", value, "空载功率实测值");
            return (Criteria) this;
        }

        public Criteria and空载功率实测值NotEqualTo(String value) {
            addCriterion("空载功率实测值 <>", value, "空载功率实测值");
            return (Criteria) this;
        }

        public Criteria and空载功率实测值GreaterThan(String value) {
            addCriterion("空载功率实测值 >", value, "空载功率实测值");
            return (Criteria) this;
        }

        public Criteria and空载功率实测值GreaterThanOrEqualTo(String value) {
            addCriterion("空载功率实测值 >=", value, "空载功率实测值");
            return (Criteria) this;
        }

        public Criteria and空载功率实测值LessThan(String value) {
            addCriterion("空载功率实测值 <", value, "空载功率实测值");
            return (Criteria) this;
        }

        public Criteria and空载功率实测值LessThanOrEqualTo(String value) {
            addCriterion("空载功率实测值 <=", value, "空载功率实测值");
            return (Criteria) this;
        }

        public Criteria and空载功率实测值Like(String value) {
            addCriterion("空载功率实测值 like", value, "空载功率实测值");
            return (Criteria) this;
        }

        public Criteria and空载功率实测值NotLike(String value) {
            addCriterion("空载功率实测值 not like", value, "空载功率实测值");
            return (Criteria) this;
        }

        public Criteria and空载功率实测值In(List<String> values) {
            addCriterion("空载功率实测值 in", values, "空载功率实测值");
            return (Criteria) this;
        }

        public Criteria and空载功率实测值NotIn(List<String> values) {
            addCriterion("空载功率实测值 not in", values, "空载功率实测值");
            return (Criteria) this;
        }

        public Criteria and空载功率实测值Between(String value1, String value2) {
            addCriterion("空载功率实测值 between", value1, value2, "空载功率实测值");
            return (Criteria) this;
        }

        public Criteria and空载功率实测值NotBetween(String value1, String value2) {
            addCriterion("空载功率实测值 not between", value1, value2, "空载功率实测值");
            return (Criteria) this;
        }

        public Criteria and空载功率测试结果IsNull() {
            addCriterion("空载功率测试结果 is null");
            return (Criteria) this;
        }

        public Criteria and空载功率测试结果IsNotNull() {
            addCriterion("空载功率测试结果 is not null");
            return (Criteria) this;
        }

        public Criteria and空载功率测试结果EqualTo(String value) {
            addCriterion("空载功率测试结果 =", value, "空载功率测试结果");
            return (Criteria) this;
        }

        public Criteria and空载功率测试结果NotEqualTo(String value) {
            addCriterion("空载功率测试结果 <>", value, "空载功率测试结果");
            return (Criteria) this;
        }

        public Criteria and空载功率测试结果GreaterThan(String value) {
            addCriterion("空载功率测试结果 >", value, "空载功率测试结果");
            return (Criteria) this;
        }

        public Criteria and空载功率测试结果GreaterThanOrEqualTo(String value) {
            addCriterion("空载功率测试结果 >=", value, "空载功率测试结果");
            return (Criteria) this;
        }

        public Criteria and空载功率测试结果LessThan(String value) {
            addCriterion("空载功率测试结果 <", value, "空载功率测试结果");
            return (Criteria) this;
        }

        public Criteria and空载功率测试结果LessThanOrEqualTo(String value) {
            addCriterion("空载功率测试结果 <=", value, "空载功率测试结果");
            return (Criteria) this;
        }

        public Criteria and空载功率测试结果Like(String value) {
            addCriterion("空载功率测试结果 like", value, "空载功率测试结果");
            return (Criteria) this;
        }

        public Criteria and空载功率测试结果NotLike(String value) {
            addCriterion("空载功率测试结果 not like", value, "空载功率测试结果");
            return (Criteria) this;
        }

        public Criteria and空载功率测试结果In(List<String> values) {
            addCriterion("空载功率测试结果 in", values, "空载功率测试结果");
            return (Criteria) this;
        }

        public Criteria and空载功率测试结果NotIn(List<String> values) {
            addCriterion("空载功率测试结果 not in", values, "空载功率测试结果");
            return (Criteria) this;
        }

        public Criteria and空载功率测试结果Between(String value1, String value2) {
            addCriterion("空载功率测试结果 between", value1, value2, "空载功率测试结果");
            return (Criteria) this;
        }

        public Criteria and空载功率测试结果NotBetween(String value1, String value2) {
            addCriterion("空载功率测试结果 not between", value1, value2, "空载功率测试结果");
            return (Criteria) this;
        }

        public Criteria and输出转速标准值IsNull() {
            addCriterion("输出转速标准值 is null");
            return (Criteria) this;
        }

        public Criteria and输出转速标准值IsNotNull() {
            addCriterion("输出转速标准值 is not null");
            return (Criteria) this;
        }

        public Criteria and输出转速标准值EqualTo(String value) {
            addCriterion("输出转速标准值 =", value, "输出转速标准值");
            return (Criteria) this;
        }

        public Criteria and输出转速标准值NotEqualTo(String value) {
            addCriterion("输出转速标准值 <>", value, "输出转速标准值");
            return (Criteria) this;
        }

        public Criteria and输出转速标准值GreaterThan(String value) {
            addCriterion("输出转速标准值 >", value, "输出转速标准值");
            return (Criteria) this;
        }

        public Criteria and输出转速标准值GreaterThanOrEqualTo(String value) {
            addCriterion("输出转速标准值 >=", value, "输出转速标准值");
            return (Criteria) this;
        }

        public Criteria and输出转速标准值LessThan(String value) {
            addCriterion("输出转速标准值 <", value, "输出转速标准值");
            return (Criteria) this;
        }

        public Criteria and输出转速标准值LessThanOrEqualTo(String value) {
            addCriterion("输出转速标准值 <=", value, "输出转速标准值");
            return (Criteria) this;
        }

        public Criteria and输出转速标准值Like(String value) {
            addCriterion("输出转速标准值 like", value, "输出转速标准值");
            return (Criteria) this;
        }

        public Criteria and输出转速标准值NotLike(String value) {
            addCriterion("输出转速标准值 not like", value, "输出转速标准值");
            return (Criteria) this;
        }

        public Criteria and输出转速标准值In(List<String> values) {
            addCriterion("输出转速标准值 in", values, "输出转速标准值");
            return (Criteria) this;
        }

        public Criteria and输出转速标准值NotIn(List<String> values) {
            addCriterion("输出转速标准值 not in", values, "输出转速标准值");
            return (Criteria) this;
        }

        public Criteria and输出转速标准值Between(String value1, String value2) {
            addCriterion("输出转速标准值 between", value1, value2, "输出转速标准值");
            return (Criteria) this;
        }

        public Criteria and输出转速标准值NotBetween(String value1, String value2) {
            addCriterion("输出转速标准值 not between", value1, value2, "输出转速标准值");
            return (Criteria) this;
        }

        public Criteria and输出转速实测值IsNull() {
            addCriterion("输出转速实测值 is null");
            return (Criteria) this;
        }

        public Criteria and输出转速实测值IsNotNull() {
            addCriterion("输出转速实测值 is not null");
            return (Criteria) this;
        }

        public Criteria and输出转速实测值EqualTo(String value) {
            addCriterion("输出转速实测值 =", value, "输出转速实测值");
            return (Criteria) this;
        }

        public Criteria and输出转速实测值NotEqualTo(String value) {
            addCriterion("输出转速实测值 <>", value, "输出转速实测值");
            return (Criteria) this;
        }

        public Criteria and输出转速实测值GreaterThan(String value) {
            addCriterion("输出转速实测值 >", value, "输出转速实测值");
            return (Criteria) this;
        }

        public Criteria and输出转速实测值GreaterThanOrEqualTo(String value) {
            addCriterion("输出转速实测值 >=", value, "输出转速实测值");
            return (Criteria) this;
        }

        public Criteria and输出转速实测值LessThan(String value) {
            addCriterion("输出转速实测值 <", value, "输出转速实测值");
            return (Criteria) this;
        }

        public Criteria and输出转速实测值LessThanOrEqualTo(String value) {
            addCriterion("输出转速实测值 <=", value, "输出转速实测值");
            return (Criteria) this;
        }

        public Criteria and输出转速实测值Like(String value) {
            addCriterion("输出转速实测值 like", value, "输出转速实测值");
            return (Criteria) this;
        }

        public Criteria and输出转速实测值NotLike(String value) {
            addCriterion("输出转速实测值 not like", value, "输出转速实测值");
            return (Criteria) this;
        }

        public Criteria and输出转速实测值In(List<String> values) {
            addCriterion("输出转速实测值 in", values, "输出转速实测值");
            return (Criteria) this;
        }

        public Criteria and输出转速实测值NotIn(List<String> values) {
            addCriterion("输出转速实测值 not in", values, "输出转速实测值");
            return (Criteria) this;
        }

        public Criteria and输出转速实测值Between(String value1, String value2) {
            addCriterion("输出转速实测值 between", value1, value2, "输出转速实测值");
            return (Criteria) this;
        }

        public Criteria and输出转速实测值NotBetween(String value1, String value2) {
            addCriterion("输出转速实测值 not between", value1, value2, "输出转速实测值");
            return (Criteria) this;
        }

        public Criteria and输出转速测试结果IsNull() {
            addCriterion("输出转速测试结果 is null");
            return (Criteria) this;
        }

        public Criteria and输出转速测试结果IsNotNull() {
            addCriterion("输出转速测试结果 is not null");
            return (Criteria) this;
        }

        public Criteria and输出转速测试结果EqualTo(String value) {
            addCriterion("输出转速测试结果 =", value, "输出转速测试结果");
            return (Criteria) this;
        }

        public Criteria and输出转速测试结果NotEqualTo(String value) {
            addCriterion("输出转速测试结果 <>", value, "输出转速测试结果");
            return (Criteria) this;
        }

        public Criteria and输出转速测试结果GreaterThan(String value) {
            addCriterion("输出转速测试结果 >", value, "输出转速测试结果");
            return (Criteria) this;
        }

        public Criteria and输出转速测试结果GreaterThanOrEqualTo(String value) {
            addCriterion("输出转速测试结果 >=", value, "输出转速测试结果");
            return (Criteria) this;
        }

        public Criteria and输出转速测试结果LessThan(String value) {
            addCriterion("输出转速测试结果 <", value, "输出转速测试结果");
            return (Criteria) this;
        }

        public Criteria and输出转速测试结果LessThanOrEqualTo(String value) {
            addCriterion("输出转速测试结果 <=", value, "输出转速测试结果");
            return (Criteria) this;
        }

        public Criteria and输出转速测试结果Like(String value) {
            addCriterion("输出转速测试结果 like", value, "输出转速测试结果");
            return (Criteria) this;
        }

        public Criteria and输出转速测试结果NotLike(String value) {
            addCriterion("输出转速测试结果 not like", value, "输出转速测试结果");
            return (Criteria) this;
        }

        public Criteria and输出转速测试结果In(List<String> values) {
            addCriterion("输出转速测试结果 in", values, "输出转速测试结果");
            return (Criteria) this;
        }

        public Criteria and输出转速测试结果NotIn(List<String> values) {
            addCriterion("输出转速测试结果 not in", values, "输出转速测试结果");
            return (Criteria) this;
        }

        public Criteria and输出转速测试结果Between(String value1, String value2) {
            addCriterion("输出转速测试结果 between", value1, value2, "输出转速测试结果");
            return (Criteria) this;
        }

        public Criteria and输出转速测试结果NotBetween(String value1, String value2) {
            addCriterion("输出转速测试结果 not between", value1, value2, "输出转速测试结果");
            return (Criteria) this;
        }

        public Criteria and耐压电压标准值IsNull() {
            addCriterion("耐压电压标准值 is null");
            return (Criteria) this;
        }

        public Criteria and耐压电压标准值IsNotNull() {
            addCriterion("耐压电压标准值 is not null");
            return (Criteria) this;
        }

        public Criteria and耐压电压标准值EqualTo(String value) {
            addCriterion("耐压电压标准值 =", value, "耐压电压标准值");
            return (Criteria) this;
        }

        public Criteria and耐压电压标准值NotEqualTo(String value) {
            addCriterion("耐压电压标准值 <>", value, "耐压电压标准值");
            return (Criteria) this;
        }

        public Criteria and耐压电压标准值GreaterThan(String value) {
            addCriterion("耐压电压标准值 >", value, "耐压电压标准值");
            return (Criteria) this;
        }

        public Criteria and耐压电压标准值GreaterThanOrEqualTo(String value) {
            addCriterion("耐压电压标准值 >=", value, "耐压电压标准值");
            return (Criteria) this;
        }

        public Criteria and耐压电压标准值LessThan(String value) {
            addCriterion("耐压电压标准值 <", value, "耐压电压标准值");
            return (Criteria) this;
        }

        public Criteria and耐压电压标准值LessThanOrEqualTo(String value) {
            addCriterion("耐压电压标准值 <=", value, "耐压电压标准值");
            return (Criteria) this;
        }

        public Criteria and耐压电压标准值Like(String value) {
            addCriterion("耐压电压标准值 like", value, "耐压电压标准值");
            return (Criteria) this;
        }

        public Criteria and耐压电压标准值NotLike(String value) {
            addCriterion("耐压电压标准值 not like", value, "耐压电压标准值");
            return (Criteria) this;
        }

        public Criteria and耐压电压标准值In(List<String> values) {
            addCriterion("耐压电压标准值 in", values, "耐压电压标准值");
            return (Criteria) this;
        }

        public Criteria and耐压电压标准值NotIn(List<String> values) {
            addCriterion("耐压电压标准值 not in", values, "耐压电压标准值");
            return (Criteria) this;
        }

        public Criteria and耐压电压标准值Between(String value1, String value2) {
            addCriterion("耐压电压标准值 between", value1, value2, "耐压电压标准值");
            return (Criteria) this;
        }

        public Criteria and耐压电压标准值NotBetween(String value1, String value2) {
            addCriterion("耐压电压标准值 not between", value1, value2, "耐压电压标准值");
            return (Criteria) this;
        }

        public Criteria and耐压电压实测值IsNull() {
            addCriterion("耐压电压实测值 is null");
            return (Criteria) this;
        }

        public Criteria and耐压电压实测值IsNotNull() {
            addCriterion("耐压电压实测值 is not null");
            return (Criteria) this;
        }

        public Criteria and耐压电压实测值EqualTo(String value) {
            addCriterion("耐压电压实测值 =", value, "耐压电压实测值");
            return (Criteria) this;
        }

        public Criteria and耐压电压实测值NotEqualTo(String value) {
            addCriterion("耐压电压实测值 <>", value, "耐压电压实测值");
            return (Criteria) this;
        }

        public Criteria and耐压电压实测值GreaterThan(String value) {
            addCriterion("耐压电压实测值 >", value, "耐压电压实测值");
            return (Criteria) this;
        }

        public Criteria and耐压电压实测值GreaterThanOrEqualTo(String value) {
            addCriterion("耐压电压实测值 >=", value, "耐压电压实测值");
            return (Criteria) this;
        }

        public Criteria and耐压电压实测值LessThan(String value) {
            addCriterion("耐压电压实测值 <", value, "耐压电压实测值");
            return (Criteria) this;
        }

        public Criteria and耐压电压实测值LessThanOrEqualTo(String value) {
            addCriterion("耐压电压实测值 <=", value, "耐压电压实测值");
            return (Criteria) this;
        }

        public Criteria and耐压电压实测值Like(String value) {
            addCriterion("耐压电压实测值 like", value, "耐压电压实测值");
            return (Criteria) this;
        }

        public Criteria and耐压电压实测值NotLike(String value) {
            addCriterion("耐压电压实测值 not like", value, "耐压电压实测值");
            return (Criteria) this;
        }

        public Criteria and耐压电压实测值In(List<String> values) {
            addCriterion("耐压电压实测值 in", values, "耐压电压实测值");
            return (Criteria) this;
        }

        public Criteria and耐压电压实测值NotIn(List<String> values) {
            addCriterion("耐压电压实测值 not in", values, "耐压电压实测值");
            return (Criteria) this;
        }

        public Criteria and耐压电压实测值Between(String value1, String value2) {
            addCriterion("耐压电压实测值 between", value1, value2, "耐压电压实测值");
            return (Criteria) this;
        }

        public Criteria and耐压电压实测值NotBetween(String value1, String value2) {
            addCriterion("耐压电压实测值 not between", value1, value2, "耐压电压实测值");
            return (Criteria) this;
        }

        public Criteria and泄漏电流标准值IsNull() {
            addCriterion("泄漏电流标准值 is null");
            return (Criteria) this;
        }

        public Criteria and泄漏电流标准值IsNotNull() {
            addCriterion("泄漏电流标准值 is not null");
            return (Criteria) this;
        }

        public Criteria and泄漏电流标准值EqualTo(String value) {
            addCriterion("泄漏电流标准值 =", value, "泄漏电流标准值");
            return (Criteria) this;
        }

        public Criteria and泄漏电流标准值NotEqualTo(String value) {
            addCriterion("泄漏电流标准值 <>", value, "泄漏电流标准值");
            return (Criteria) this;
        }

        public Criteria and泄漏电流标准值GreaterThan(String value) {
            addCriterion("泄漏电流标准值 >", value, "泄漏电流标准值");
            return (Criteria) this;
        }

        public Criteria and泄漏电流标准值GreaterThanOrEqualTo(String value) {
            addCriterion("泄漏电流标准值 >=", value, "泄漏电流标准值");
            return (Criteria) this;
        }

        public Criteria and泄漏电流标准值LessThan(String value) {
            addCriterion("泄漏电流标准值 <", value, "泄漏电流标准值");
            return (Criteria) this;
        }

        public Criteria and泄漏电流标准值LessThanOrEqualTo(String value) {
            addCriterion("泄漏电流标准值 <=", value, "泄漏电流标准值");
            return (Criteria) this;
        }

        public Criteria and泄漏电流标准值Like(String value) {
            addCriterion("泄漏电流标准值 like", value, "泄漏电流标准值");
            return (Criteria) this;
        }

        public Criteria and泄漏电流标准值NotLike(String value) {
            addCriterion("泄漏电流标准值 not like", value, "泄漏电流标准值");
            return (Criteria) this;
        }

        public Criteria and泄漏电流标准值In(List<String> values) {
            addCriterion("泄漏电流标准值 in", values, "泄漏电流标准值");
            return (Criteria) this;
        }

        public Criteria and泄漏电流标准值NotIn(List<String> values) {
            addCriterion("泄漏电流标准值 not in", values, "泄漏电流标准值");
            return (Criteria) this;
        }

        public Criteria and泄漏电流标准值Between(String value1, String value2) {
            addCriterion("泄漏电流标准值 between", value1, value2, "泄漏电流标准值");
            return (Criteria) this;
        }

        public Criteria and泄漏电流标准值NotBetween(String value1, String value2) {
            addCriterion("泄漏电流标准值 not between", value1, value2, "泄漏电流标准值");
            return (Criteria) this;
        }

        public Criteria and泄漏电流实测值IsNull() {
            addCriterion("泄漏电流实测值 is null");
            return (Criteria) this;
        }

        public Criteria and泄漏电流实测值IsNotNull() {
            addCriterion("泄漏电流实测值 is not null");
            return (Criteria) this;
        }

        public Criteria and泄漏电流实测值EqualTo(String value) {
            addCriterion("泄漏电流实测值 =", value, "泄漏电流实测值");
            return (Criteria) this;
        }

        public Criteria and泄漏电流实测值NotEqualTo(String value) {
            addCriterion("泄漏电流实测值 <>", value, "泄漏电流实测值");
            return (Criteria) this;
        }

        public Criteria and泄漏电流实测值GreaterThan(String value) {
            addCriterion("泄漏电流实测值 >", value, "泄漏电流实测值");
            return (Criteria) this;
        }

        public Criteria and泄漏电流实测值GreaterThanOrEqualTo(String value) {
            addCriterion("泄漏电流实测值 >=", value, "泄漏电流实测值");
            return (Criteria) this;
        }

        public Criteria and泄漏电流实测值LessThan(String value) {
            addCriterion("泄漏电流实测值 <", value, "泄漏电流实测值");
            return (Criteria) this;
        }

        public Criteria and泄漏电流实测值LessThanOrEqualTo(String value) {
            addCriterion("泄漏电流实测值 <=", value, "泄漏电流实测值");
            return (Criteria) this;
        }

        public Criteria and泄漏电流实测值Like(String value) {
            addCriterion("泄漏电流实测值 like", value, "泄漏电流实测值");
            return (Criteria) this;
        }

        public Criteria and泄漏电流实测值NotLike(String value) {
            addCriterion("泄漏电流实测值 not like", value, "泄漏电流实测值");
            return (Criteria) this;
        }

        public Criteria and泄漏电流实测值In(List<String> values) {
            addCriterion("泄漏电流实测值 in", values, "泄漏电流实测值");
            return (Criteria) this;
        }

        public Criteria and泄漏电流实测值NotIn(List<String> values) {
            addCriterion("泄漏电流实测值 not in", values, "泄漏电流实测值");
            return (Criteria) this;
        }

        public Criteria and泄漏电流实测值Between(String value1, String value2) {
            addCriterion("泄漏电流实测值 between", value1, value2, "泄漏电流实测值");
            return (Criteria) this;
        }

        public Criteria and泄漏电流实测值NotBetween(String value1, String value2) {
            addCriterion("泄漏电流实测值 not between", value1, value2, "泄漏电流实测值");
            return (Criteria) this;
        }

        public Criteria and泄漏电流测试结果IsNull() {
            addCriterion("泄漏电流测试结果 is null");
            return (Criteria) this;
        }

        public Criteria and泄漏电流测试结果IsNotNull() {
            addCriterion("泄漏电流测试结果 is not null");
            return (Criteria) this;
        }

        public Criteria and泄漏电流测试结果EqualTo(String value) {
            addCriterion("泄漏电流测试结果 =", value, "泄漏电流测试结果");
            return (Criteria) this;
        }

        public Criteria and泄漏电流测试结果NotEqualTo(String value) {
            addCriterion("泄漏电流测试结果 <>", value, "泄漏电流测试结果");
            return (Criteria) this;
        }

        public Criteria and泄漏电流测试结果GreaterThan(String value) {
            addCriterion("泄漏电流测试结果 >", value, "泄漏电流测试结果");
            return (Criteria) this;
        }

        public Criteria and泄漏电流测试结果GreaterThanOrEqualTo(String value) {
            addCriterion("泄漏电流测试结果 >=", value, "泄漏电流测试结果");
            return (Criteria) this;
        }

        public Criteria and泄漏电流测试结果LessThan(String value) {
            addCriterion("泄漏电流测试结果 <", value, "泄漏电流测试结果");
            return (Criteria) this;
        }

        public Criteria and泄漏电流测试结果LessThanOrEqualTo(String value) {
            addCriterion("泄漏电流测试结果 <=", value, "泄漏电流测试结果");
            return (Criteria) this;
        }

        public Criteria and泄漏电流测试结果Like(String value) {
            addCriterion("泄漏电流测试结果 like", value, "泄漏电流测试结果");
            return (Criteria) this;
        }

        public Criteria and泄漏电流测试结果NotLike(String value) {
            addCriterion("泄漏电流测试结果 not like", value, "泄漏电流测试结果");
            return (Criteria) this;
        }

        public Criteria and泄漏电流测试结果In(List<String> values) {
            addCriterion("泄漏电流测试结果 in", values, "泄漏电流测试结果");
            return (Criteria) this;
        }

        public Criteria and泄漏电流测试结果NotIn(List<String> values) {
            addCriterion("泄漏电流测试结果 not in", values, "泄漏电流测试结果");
            return (Criteria) this;
        }

        public Criteria and泄漏电流测试结果Between(String value1, String value2) {
            addCriterion("泄漏电流测试结果 between", value1, value2, "泄漏电流测试结果");
            return (Criteria) this;
        }

        public Criteria and泄漏电流测试结果NotBetween(String value1, String value2) {
            addCriterion("泄漏电流测试结果 not between", value1, value2, "泄漏电流测试结果");
            return (Criteria) this;
        }

        public Criteria and铭牌数据测试结果IsNull() {
            addCriterion("铭牌数据测试结果 is null");
            return (Criteria) this;
        }

        public Criteria and铭牌数据测试结果IsNotNull() {
            addCriterion("铭牌数据测试结果 is not null");
            return (Criteria) this;
        }

        public Criteria and铭牌数据测试结果EqualTo(String value) {
            addCriterion("铭牌数据测试结果 =", value, "铭牌数据测试结果");
            return (Criteria) this;
        }

        public Criteria and铭牌数据测试结果NotEqualTo(String value) {
            addCriterion("铭牌数据测试结果 <>", value, "铭牌数据测试结果");
            return (Criteria) this;
        }

        public Criteria and铭牌数据测试结果GreaterThan(String value) {
            addCriterion("铭牌数据测试结果 >", value, "铭牌数据测试结果");
            return (Criteria) this;
        }

        public Criteria and铭牌数据测试结果GreaterThanOrEqualTo(String value) {
            addCriterion("铭牌数据测试结果 >=", value, "铭牌数据测试结果");
            return (Criteria) this;
        }

        public Criteria and铭牌数据测试结果LessThan(String value) {
            addCriterion("铭牌数据测试结果 <", value, "铭牌数据测试结果");
            return (Criteria) this;
        }

        public Criteria and铭牌数据测试结果LessThanOrEqualTo(String value) {
            addCriterion("铭牌数据测试结果 <=", value, "铭牌数据测试结果");
            return (Criteria) this;
        }

        public Criteria and铭牌数据测试结果Like(String value) {
            addCriterion("铭牌数据测试结果 like", value, "铭牌数据测试结果");
            return (Criteria) this;
        }

        public Criteria and铭牌数据测试结果NotLike(String value) {
            addCriterion("铭牌数据测试结果 not like", value, "铭牌数据测试结果");
            return (Criteria) this;
        }

        public Criteria and铭牌数据测试结果In(List<String> values) {
            addCriterion("铭牌数据测试结果 in", values, "铭牌数据测试结果");
            return (Criteria) this;
        }

        public Criteria and铭牌数据测试结果NotIn(List<String> values) {
            addCriterion("铭牌数据测试结果 not in", values, "铭牌数据测试结果");
            return (Criteria) this;
        }

        public Criteria and铭牌数据测试结果Between(String value1, String value2) {
            addCriterion("铭牌数据测试结果 between", value1, value2, "铭牌数据测试结果");
            return (Criteria) this;
        }

        public Criteria and铭牌数据测试结果NotBetween(String value1, String value2) {
            addCriterion("铭牌数据测试结果 not between", value1, value2, "铭牌数据测试结果");
            return (Criteria) this;
        }

        public Criteria and表面缺陷测试结果IsNull() {
            addCriterion("表面缺陷测试结果 is null");
            return (Criteria) this;
        }

        public Criteria and表面缺陷测试结果IsNotNull() {
            addCriterion("表面缺陷测试结果 is not null");
            return (Criteria) this;
        }

        public Criteria and表面缺陷测试结果EqualTo(String value) {
            addCriterion("表面缺陷测试结果 =", value, "表面缺陷测试结果");
            return (Criteria) this;
        }

        public Criteria and表面缺陷测试结果NotEqualTo(String value) {
            addCriterion("表面缺陷测试结果 <>", value, "表面缺陷测试结果");
            return (Criteria) this;
        }

        public Criteria and表面缺陷测试结果GreaterThan(String value) {
            addCriterion("表面缺陷测试结果 >", value, "表面缺陷测试结果");
            return (Criteria) this;
        }

        public Criteria and表面缺陷测试结果GreaterThanOrEqualTo(String value) {
            addCriterion("表面缺陷测试结果 >=", value, "表面缺陷测试结果");
            return (Criteria) this;
        }

        public Criteria and表面缺陷测试结果LessThan(String value) {
            addCriterion("表面缺陷测试结果 <", value, "表面缺陷测试结果");
            return (Criteria) this;
        }

        public Criteria and表面缺陷测试结果LessThanOrEqualTo(String value) {
            addCriterion("表面缺陷测试结果 <=", value, "表面缺陷测试结果");
            return (Criteria) this;
        }

        public Criteria and表面缺陷测试结果Like(String value) {
            addCriterion("表面缺陷测试结果 like", value, "表面缺陷测试结果");
            return (Criteria) this;
        }

        public Criteria and表面缺陷测试结果NotLike(String value) {
            addCriterion("表面缺陷测试结果 not like", value, "表面缺陷测试结果");
            return (Criteria) this;
        }

        public Criteria and表面缺陷测试结果In(List<String> values) {
            addCriterion("表面缺陷测试结果 in", values, "表面缺陷测试结果");
            return (Criteria) this;
        }

        public Criteria and表面缺陷测试结果NotIn(List<String> values) {
            addCriterion("表面缺陷测试结果 not in", values, "表面缺陷测试结果");
            return (Criteria) this;
        }

        public Criteria and表面缺陷测试结果Between(String value1, String value2) {
            addCriterion("表面缺陷测试结果 between", value1, value2, "表面缺陷测试结果");
            return (Criteria) this;
        }

        public Criteria and表面缺陷测试结果NotBetween(String value1, String value2) {
            addCriterion("表面缺陷测试结果 not between", value1, value2, "表面缺陷测试结果");
            return (Criteria) this;
        }

        public Criteria and装配方式测试结果IsNull() {
            addCriterion("装配方式测试结果 is null");
            return (Criteria) this;
        }

        public Criteria and装配方式测试结果IsNotNull() {
            addCriterion("装配方式测试结果 is not null");
            return (Criteria) this;
        }

        public Criteria and装配方式测试结果EqualTo(String value) {
            addCriterion("装配方式测试结果 =", value, "装配方式测试结果");
            return (Criteria) this;
        }

        public Criteria and装配方式测试结果NotEqualTo(String value) {
            addCriterion("装配方式测试结果 <>", value, "装配方式测试结果");
            return (Criteria) this;
        }

        public Criteria and装配方式测试结果GreaterThan(String value) {
            addCriterion("装配方式测试结果 >", value, "装配方式测试结果");
            return (Criteria) this;
        }

        public Criteria and装配方式测试结果GreaterThanOrEqualTo(String value) {
            addCriterion("装配方式测试结果 >=", value, "装配方式测试结果");
            return (Criteria) this;
        }

        public Criteria and装配方式测试结果LessThan(String value) {
            addCriterion("装配方式测试结果 <", value, "装配方式测试结果");
            return (Criteria) this;
        }

        public Criteria and装配方式测试结果LessThanOrEqualTo(String value) {
            addCriterion("装配方式测试结果 <=", value, "装配方式测试结果");
            return (Criteria) this;
        }

        public Criteria and装配方式测试结果Like(String value) {
            addCriterion("装配方式测试结果 like", value, "装配方式测试结果");
            return (Criteria) this;
        }

        public Criteria and装配方式测试结果NotLike(String value) {
            addCriterion("装配方式测试结果 not like", value, "装配方式测试结果");
            return (Criteria) this;
        }

        public Criteria and装配方式测试结果In(List<String> values) {
            addCriterion("装配方式测试结果 in", values, "装配方式测试结果");
            return (Criteria) this;
        }

        public Criteria and装配方式测试结果NotIn(List<String> values) {
            addCriterion("装配方式测试结果 not in", values, "装配方式测试结果");
            return (Criteria) this;
        }

        public Criteria and装配方式测试结果Between(String value1, String value2) {
            addCriterion("装配方式测试结果 between", value1, value2, "装配方式测试结果");
            return (Criteria) this;
        }

        public Criteria and装配方式测试结果NotBetween(String value1, String value2) {
            addCriterion("装配方式测试结果 not between", value1, value2, "装配方式测试结果");
            return (Criteria) this;
        }

        public Criteria and联结尺寸测试结果IsNull() {
            addCriterion("联结尺寸测试结果 is null");
            return (Criteria) this;
        }

        public Criteria and联结尺寸测试结果IsNotNull() {
            addCriterion("联结尺寸测试结果 is not null");
            return (Criteria) this;
        }

        public Criteria and联结尺寸测试结果EqualTo(String value) {
            addCriterion("联结尺寸测试结果 =", value, "联结尺寸测试结果");
            return (Criteria) this;
        }

        public Criteria and联结尺寸测试结果NotEqualTo(String value) {
            addCriterion("联结尺寸测试结果 <>", value, "联结尺寸测试结果");
            return (Criteria) this;
        }

        public Criteria and联结尺寸测试结果GreaterThan(String value) {
            addCriterion("联结尺寸测试结果 >", value, "联结尺寸测试结果");
            return (Criteria) this;
        }

        public Criteria and联结尺寸测试结果GreaterThanOrEqualTo(String value) {
            addCriterion("联结尺寸测试结果 >=", value, "联结尺寸测试结果");
            return (Criteria) this;
        }

        public Criteria and联结尺寸测试结果LessThan(String value) {
            addCriterion("联结尺寸测试结果 <", value, "联结尺寸测试结果");
            return (Criteria) this;
        }

        public Criteria and联结尺寸测试结果LessThanOrEqualTo(String value) {
            addCriterion("联结尺寸测试结果 <=", value, "联结尺寸测试结果");
            return (Criteria) this;
        }

        public Criteria and联结尺寸测试结果Like(String value) {
            addCriterion("联结尺寸测试结果 like", value, "联结尺寸测试结果");
            return (Criteria) this;
        }

        public Criteria and联结尺寸测试结果NotLike(String value) {
            addCriterion("联结尺寸测试结果 not like", value, "联结尺寸测试结果");
            return (Criteria) this;
        }

        public Criteria and联结尺寸测试结果In(List<String> values) {
            addCriterion("联结尺寸测试结果 in", values, "联结尺寸测试结果");
            return (Criteria) this;
        }

        public Criteria and联结尺寸测试结果NotIn(List<String> values) {
            addCriterion("联结尺寸测试结果 not in", values, "联结尺寸测试结果");
            return (Criteria) this;
        }

        public Criteria and联结尺寸测试结果Between(String value1, String value2) {
            addCriterion("联结尺寸测试结果 between", value1, value2, "联结尺寸测试结果");
            return (Criteria) this;
        }

        public Criteria and联结尺寸测试结果NotBetween(String value1, String value2) {
            addCriterion("联结尺寸测试结果 not between", value1, value2, "联结尺寸测试结果");
            return (Criteria) this;
        }

        public Criteria and异常噪音测试结果IsNull() {
            addCriterion("异常噪音测试结果 is null");
            return (Criteria) this;
        }

        public Criteria and异常噪音测试结果IsNotNull() {
            addCriterion("异常噪音测试结果 is not null");
            return (Criteria) this;
        }

        public Criteria and异常噪音测试结果EqualTo(String value) {
            addCriterion("异常噪音测试结果 =", value, "异常噪音测试结果");
            return (Criteria) this;
        }

        public Criteria and异常噪音测试结果NotEqualTo(String value) {
            addCriterion("异常噪音测试结果 <>", value, "异常噪音测试结果");
            return (Criteria) this;
        }

        public Criteria and异常噪音测试结果GreaterThan(String value) {
            addCriterion("异常噪音测试结果 >", value, "异常噪音测试结果");
            return (Criteria) this;
        }

        public Criteria and异常噪音测试结果GreaterThanOrEqualTo(String value) {
            addCriterion("异常噪音测试结果 >=", value, "异常噪音测试结果");
            return (Criteria) this;
        }

        public Criteria and异常噪音测试结果LessThan(String value) {
            addCriterion("异常噪音测试结果 <", value, "异常噪音测试结果");
            return (Criteria) this;
        }

        public Criteria and异常噪音测试结果LessThanOrEqualTo(String value) {
            addCriterion("异常噪音测试结果 <=", value, "异常噪音测试结果");
            return (Criteria) this;
        }

        public Criteria and异常噪音测试结果Like(String value) {
            addCriterion("异常噪音测试结果 like", value, "异常噪音测试结果");
            return (Criteria) this;
        }

        public Criteria and异常噪音测试结果NotLike(String value) {
            addCriterion("异常噪音测试结果 not like", value, "异常噪音测试结果");
            return (Criteria) this;
        }

        public Criteria and异常噪音测试结果In(List<String> values) {
            addCriterion("异常噪音测试结果 in", values, "异常噪音测试结果");
            return (Criteria) this;
        }

        public Criteria and异常噪音测试结果NotIn(List<String> values) {
            addCriterion("异常噪音测试结果 not in", values, "异常噪音测试结果");
            return (Criteria) this;
        }

        public Criteria and异常噪音测试结果Between(String value1, String value2) {
            addCriterion("异常噪音测试结果 between", value1, value2, "异常噪音测试结果");
            return (Criteria) this;
        }

        public Criteria and异常噪音测试结果NotBetween(String value1, String value2) {
            addCriterion("异常噪音测试结果 not between", value1, value2, "异常噪音测试结果");
            return (Criteria) this;
        }

        public Criteria and特殊要求测试结果IsNull() {
            addCriterion("特殊要求测试结果 is null");
            return (Criteria) this;
        }

        public Criteria and特殊要求测试结果IsNotNull() {
            addCriterion("特殊要求测试结果 is not null");
            return (Criteria) this;
        }

        public Criteria and特殊要求测试结果EqualTo(String value) {
            addCriterion("特殊要求测试结果 =", value, "特殊要求测试结果");
            return (Criteria) this;
        }

        public Criteria and特殊要求测试结果NotEqualTo(String value) {
            addCriterion("特殊要求测试结果 <>", value, "特殊要求测试结果");
            return (Criteria) this;
        }

        public Criteria and特殊要求测试结果GreaterThan(String value) {
            addCriterion("特殊要求测试结果 >", value, "特殊要求测试结果");
            return (Criteria) this;
        }

        public Criteria and特殊要求测试结果GreaterThanOrEqualTo(String value) {
            addCriterion("特殊要求测试结果 >=", value, "特殊要求测试结果");
            return (Criteria) this;
        }

        public Criteria and特殊要求测试结果LessThan(String value) {
            addCriterion("特殊要求测试结果 <", value, "特殊要求测试结果");
            return (Criteria) this;
        }

        public Criteria and特殊要求测试结果LessThanOrEqualTo(String value) {
            addCriterion("特殊要求测试结果 <=", value, "特殊要求测试结果");
            return (Criteria) this;
        }

        public Criteria and特殊要求测试结果Like(String value) {
            addCriterion("特殊要求测试结果 like", value, "特殊要求测试结果");
            return (Criteria) this;
        }

        public Criteria and特殊要求测试结果NotLike(String value) {
            addCriterion("特殊要求测试结果 not like", value, "特殊要求测试结果");
            return (Criteria) this;
        }

        public Criteria and特殊要求测试结果In(List<String> values) {
            addCriterion("特殊要求测试结果 in", values, "特殊要求测试结果");
            return (Criteria) this;
        }

        public Criteria and特殊要求测试结果NotIn(List<String> values) {
            addCriterion("特殊要求测试结果 not in", values, "特殊要求测试结果");
            return (Criteria) this;
        }

        public Criteria and特殊要求测试结果Between(String value1, String value2) {
            addCriterion("特殊要求测试结果 between", value1, value2, "特殊要求测试结果");
            return (Criteria) this;
        }

        public Criteria and特殊要求测试结果NotBetween(String value1, String value2) {
            addCriterion("特殊要求测试结果 not between", value1, value2, "特殊要求测试结果");
            return (Criteria) this;
        }

        public Criteria and减速机测试结果IsNull() {
            addCriterion("减速机测试结果 is null");
            return (Criteria) this;
        }

        public Criteria and减速机测试结果IsNotNull() {
            addCriterion("减速机测试结果 is not null");
            return (Criteria) this;
        }

        public Criteria and减速机测试结果EqualTo(String value) {
            addCriterion("减速机测试结果 =", value, "减速机测试结果");
            return (Criteria) this;
        }

        public Criteria and减速机测试结果NotEqualTo(String value) {
            addCriterion("减速机测试结果 <>", value, "减速机测试结果");
            return (Criteria) this;
        }

        public Criteria and减速机测试结果GreaterThan(String value) {
            addCriterion("减速机测试结果 >", value, "减速机测试结果");
            return (Criteria) this;
        }

        public Criteria and减速机测试结果GreaterThanOrEqualTo(String value) {
            addCriterion("减速机测试结果 >=", value, "减速机测试结果");
            return (Criteria) this;
        }

        public Criteria and减速机测试结果LessThan(String value) {
            addCriterion("减速机测试结果 <", value, "减速机测试结果");
            return (Criteria) this;
        }

        public Criteria and减速机测试结果LessThanOrEqualTo(String value) {
            addCriterion("减速机测试结果 <=", value, "减速机测试结果");
            return (Criteria) this;
        }

        public Criteria and减速机测试结果Like(String value) {
            addCriterion("减速机测试结果 like", value, "减速机测试结果");
            return (Criteria) this;
        }

        public Criteria and减速机测试结果NotLike(String value) {
            addCriterion("减速机测试结果 not like", value, "减速机测试结果");
            return (Criteria) this;
        }

        public Criteria and减速机测试结果In(List<String> values) {
            addCriterion("减速机测试结果 in", values, "减速机测试结果");
            return (Criteria) this;
        }

        public Criteria and减速机测试结果NotIn(List<String> values) {
            addCriterion("减速机测试结果 not in", values, "减速机测试结果");
            return (Criteria) this;
        }

        public Criteria and减速机测试结果Between(String value1, String value2) {
            addCriterion("减速机测试结果 between", value1, value2, "减速机测试结果");
            return (Criteria) this;
        }

        public Criteria and减速机测试结果NotBetween(String value1, String value2) {
            addCriterion("减速机测试结果 not between", value1, value2, "减速机测试结果");
            return (Criteria) this;
        }

        public Criteria and操作员IsNull() {
            addCriterion("操作员 is null");
            return (Criteria) this;
        }

        public Criteria and操作员IsNotNull() {
            addCriterion("操作员 is not null");
            return (Criteria) this;
        }

        public Criteria and操作员EqualTo(String value) {
            addCriterion("操作员 =", value, "操作员");
            return (Criteria) this;
        }

        public Criteria and操作员NotEqualTo(String value) {
            addCriterion("操作员 <>", value, "操作员");
            return (Criteria) this;
        }

        public Criteria and操作员GreaterThan(String value) {
            addCriterion("操作员 >", value, "操作员");
            return (Criteria) this;
        }

        public Criteria and操作员GreaterThanOrEqualTo(String value) {
            addCriterion("操作员 >=", value, "操作员");
            return (Criteria) this;
        }

        public Criteria and操作员LessThan(String value) {
            addCriterion("操作员 <", value, "操作员");
            return (Criteria) this;
        }

        public Criteria and操作员LessThanOrEqualTo(String value) {
            addCriterion("操作员 <=", value, "操作员");
            return (Criteria) this;
        }

        public Criteria and操作员Like(String value) {
            addCriterion("操作员 like", value, "操作员");
            return (Criteria) this;
        }

        public Criteria and操作员NotLike(String value) {
            addCriterion("操作员 not like", value, "操作员");
            return (Criteria) this;
        }

        public Criteria and操作员In(List<String> values) {
            addCriterion("操作员 in", values, "操作员");
            return (Criteria) this;
        }

        public Criteria and操作员NotIn(List<String> values) {
            addCriterion("操作员 not in", values, "操作员");
            return (Criteria) this;
        }

        public Criteria and操作员Between(String value1, String value2) {
            addCriterion("操作员 between", value1, value2, "操作员");
            return (Criteria) this;
        }

        public Criteria and操作员NotBetween(String value1, String value2) {
            addCriterion("操作员 not between", value1, value2, "操作员");
            return (Criteria) this;
        }

        public Criteria and测试日期IsNull() {
            addCriterion("测试日期 is null");
            return (Criteria) this;
        }

        public Criteria and测试日期IsNotNull() {
            addCriterion("测试日期 is not null");
            return (Criteria) this;
        }

        public Criteria and测试日期EqualTo(String value) {
            addCriterion("测试日期 =", value, "测试日期");
            return (Criteria) this;
        }

        public Criteria and测试日期NotEqualTo(String value) {
            addCriterion("测试日期 <>", value, "测试日期");
            return (Criteria) this;
        }

        public Criteria and测试日期GreaterThan(String value) {
            addCriterion("测试日期 >", value, "测试日期");
            return (Criteria) this;
        }

        public Criteria and测试日期GreaterThanOrEqualTo(String value) {
            addCriterion("测试日期 >=", value, "测试日期");
            return (Criteria) this;
        }

        public Criteria and测试日期LessThan(String value) {
            addCriterion("测试日期 <", value, "测试日期");
            return (Criteria) this;
        }

        public Criteria and测试日期LessThanOrEqualTo(String value) {
            addCriterion("测试日期 <=", value, "测试日期");
            return (Criteria) this;
        }

        public Criteria and测试日期Like(String value) {
            addCriterion("测试日期 like", value, "测试日期");
            return (Criteria) this;
        }

        public Criteria and测试日期NotLike(String value) {
            addCriterion("测试日期 not like", value, "测试日期");
            return (Criteria) this;
        }

        public Criteria and测试日期In(List<String> values) {
            addCriterion("测试日期 in", values, "测试日期");
            return (Criteria) this;
        }

        public Criteria and测试日期NotIn(List<String> values) {
            addCriterion("测试日期 not in", values, "测试日期");
            return (Criteria) this;
        }

        public Criteria and测试日期Between(String value1, String value2) {
            addCriterion("测试日期 between", value1, value2, "测试日期");
            return (Criteria) this;
        }

        public Criteria and测试日期NotBetween(String value1, String value2) {
            addCriterion("测试日期 not between", value1, value2, "测试日期");
            return (Criteria) this;
        }

        public Criteria and测试机名称IsNull() {
            addCriterion("测试机名称 is null");
            return (Criteria) this;
        }

        public Criteria and测试机名称IsNotNull() {
            addCriterion("测试机名称 is not null");
            return (Criteria) this;
        }

        public Criteria and测试机名称EqualTo(String value) {
            addCriterion("测试机名称 =", value, "测试机名称");
            return (Criteria) this;
        }

        public Criteria and测试机名称NotEqualTo(String value) {
            addCriterion("测试机名称 <>", value, "测试机名称");
            return (Criteria) this;
        }

        public Criteria and测试机名称GreaterThan(String value) {
            addCriterion("测试机名称 >", value, "测试机名称");
            return (Criteria) this;
        }

        public Criteria and测试机名称GreaterThanOrEqualTo(String value) {
            addCriterion("测试机名称 >=", value, "测试机名称");
            return (Criteria) this;
        }

        public Criteria and测试机名称LessThan(String value) {
            addCriterion("测试机名称 <", value, "测试机名称");
            return (Criteria) this;
        }

        public Criteria and测试机名称LessThanOrEqualTo(String value) {
            addCriterion("测试机名称 <=", value, "测试机名称");
            return (Criteria) this;
        }

        public Criteria and测试机名称Like(String value) {
            addCriterion("测试机名称 like", value, "测试机名称");
            return (Criteria) this;
        }

        public Criteria and测试机名称NotLike(String value) {
            addCriterion("测试机名称 not like", value, "测试机名称");
            return (Criteria) this;
        }

        public Criteria and测试机名称In(List<String> values) {
            addCriterion("测试机名称 in", values, "测试机名称");
            return (Criteria) this;
        }

        public Criteria and测试机名称NotIn(List<String> values) {
            addCriterion("测试机名称 not in", values, "测试机名称");
            return (Criteria) this;
        }

        public Criteria and测试机名称Between(String value1, String value2) {
            addCriterion("测试机名称 between", value1, value2, "测试机名称");
            return (Criteria) this;
        }

        public Criteria and测试机名称NotBetween(String value1, String value2) {
            addCriterion("测试机名称 not between", value1, value2, "测试机名称");
            return (Criteria) this;
        }

        public Criteria and测试时间IsNull() {
            addCriterion("测试时间 is null");
            return (Criteria) this;
        }

        public Criteria and测试时间IsNotNull() {
            addCriterion("测试时间 is not null");
            return (Criteria) this;
        }

        public Criteria and测试时间EqualTo(String value) {
            addCriterion("测试时间 =", value, "测试时间");
            return (Criteria) this;
        }

        public Criteria and测试时间NotEqualTo(String value) {
            addCriterion("测试时间 <>", value, "测试时间");
            return (Criteria) this;
        }

        public Criteria and测试时间GreaterThan(String value) {
            addCriterion("测试时间 >", value, "测试时间");
            return (Criteria) this;
        }

        public Criteria and测试时间GreaterThanOrEqualTo(String value) {
            addCriterion("测试时间 >=", value, "测试时间");
            return (Criteria) this;
        }

        public Criteria and测试时间LessThan(String value) {
            addCriterion("测试时间 <", value, "测试时间");
            return (Criteria) this;
        }

        public Criteria and测试时间LessThanOrEqualTo(String value) {
            addCriterion("测试时间 <=", value, "测试时间");
            return (Criteria) this;
        }

        public Criteria and测试时间Like(String value) {
            addCriterion("测试时间 like", value, "测试时间");
            return (Criteria) this;
        }

        public Criteria and测试时间NotLike(String value) {
            addCriterion("测试时间 not like", value, "测试时间");
            return (Criteria) this;
        }

        public Criteria and测试时间In(List<String> values) {
            addCriterion("测试时间 in", values, "测试时间");
            return (Criteria) this;
        }

        public Criteria and测试时间NotIn(List<String> values) {
            addCriterion("测试时间 not in", values, "测试时间");
            return (Criteria) this;
        }

        public Criteria and测试时间Between(String value1, String value2) {
            addCriterion("测试时间 between", value1, value2, "测试时间");
            return (Criteria) this;
        }

        public Criteria and测试时间NotBetween(String value1, String value2) {
            addCriterion("测试时间 not between", value1, value2, "测试时间");
            return (Criteria) this;
        }

        public Criteria and特殊放行标记IsNull() {
            addCriterion("特殊放行标记 is null");
            return (Criteria) this;
        }

        public Criteria and特殊放行标记IsNotNull() {
            addCriterion("特殊放行标记 is not null");
            return (Criteria) this;
        }

        public Criteria and特殊放行标记EqualTo(String value) {
            addCriterion("特殊放行标记 =", value, "特殊放行标记");
            return (Criteria) this;
        }

        public Criteria and特殊放行标记NotEqualTo(String value) {
            addCriterion("特殊放行标记 <>", value, "特殊放行标记");
            return (Criteria) this;
        }

        public Criteria and特殊放行标记GreaterThan(String value) {
            addCriterion("特殊放行标记 >", value, "特殊放行标记");
            return (Criteria) this;
        }

        public Criteria and特殊放行标记GreaterThanOrEqualTo(String value) {
            addCriterion("特殊放行标记 >=", value, "特殊放行标记");
            return (Criteria) this;
        }

        public Criteria and特殊放行标记LessThan(String value) {
            addCriterion("特殊放行标记 <", value, "特殊放行标记");
            return (Criteria) this;
        }

        public Criteria and特殊放行标记LessThanOrEqualTo(String value) {
            addCriterion("特殊放行标记 <=", value, "特殊放行标记");
            return (Criteria) this;
        }

        public Criteria and特殊放行标记Like(String value) {
            addCriterion("特殊放行标记 like", value, "特殊放行标记");
            return (Criteria) this;
        }

        public Criteria and特殊放行标记NotLike(String value) {
            addCriterion("特殊放行标记 not like", value, "特殊放行标记");
            return (Criteria) this;
        }

        public Criteria and特殊放行标记In(List<String> values) {
            addCriterion("特殊放行标记 in", values, "特殊放行标记");
            return (Criteria) this;
        }

        public Criteria and特殊放行标记NotIn(List<String> values) {
            addCriterion("特殊放行标记 not in", values, "特殊放行标记");
            return (Criteria) this;
        }

        public Criteria and特殊放行标记Between(String value1, String value2) {
            addCriterion("特殊放行标记 between", value1, value2, "特殊放行标记");
            return (Criteria) this;
        }

        public Criteria and特殊放行标记NotBetween(String value1, String value2) {
            addCriterion("特殊放行标记 not between", value1, value2, "特殊放行标记");
            return (Criteria) this;
        }

        public Criteria and确认人IsNull() {
            addCriterion("确认人 is null");
            return (Criteria) this;
        }

        public Criteria and确认人IsNotNull() {
            addCriterion("确认人 is not null");
            return (Criteria) this;
        }

        public Criteria and确认人EqualTo(String value) {
            addCriterion("确认人 =", value, "确认人");
            return (Criteria) this;
        }

        public Criteria and确认人NotEqualTo(String value) {
            addCriterion("确认人 <>", value, "确认人");
            return (Criteria) this;
        }

        public Criteria and确认人GreaterThan(String value) {
            addCriterion("确认人 >", value, "确认人");
            return (Criteria) this;
        }

        public Criteria and确认人GreaterThanOrEqualTo(String value) {
            addCriterion("确认人 >=", value, "确认人");
            return (Criteria) this;
        }

        public Criteria and确认人LessThan(String value) {
            addCriterion("确认人 <", value, "确认人");
            return (Criteria) this;
        }

        public Criteria and确认人LessThanOrEqualTo(String value) {
            addCriterion("确认人 <=", value, "确认人");
            return (Criteria) this;
        }

        public Criteria and确认人Like(String value) {
            addCriterion("确认人 like", value, "确认人");
            return (Criteria) this;
        }

        public Criteria and确认人NotLike(String value) {
            addCriterion("确认人 not like", value, "确认人");
            return (Criteria) this;
        }

        public Criteria and确认人In(List<String> values) {
            addCriterion("确认人 in", values, "确认人");
            return (Criteria) this;
        }

        public Criteria and确认人NotIn(List<String> values) {
            addCriterion("确认人 not in", values, "确认人");
            return (Criteria) this;
        }

        public Criteria and确认人Between(String value1, String value2) {
            addCriterion("确认人 between", value1, value2, "确认人");
            return (Criteria) this;
        }

        public Criteria and确认人NotBetween(String value1, String value2) {
            addCriterion("确认人 not between", value1, value2, "确认人");
            return (Criteria) this;
        }

        public Criteria and确认时间IsNull() {
            addCriterion("确认时间 is null");
            return (Criteria) this;
        }

        public Criteria and确认时间IsNotNull() {
            addCriterion("确认时间 is not null");
            return (Criteria) this;
        }

        public Criteria and确认时间EqualTo(Date value) {
            addCriterion("确认时间 =", value, "确认时间");
            return (Criteria) this;
        }

        public Criteria and确认时间NotEqualTo(Date value) {
            addCriterion("确认时间 <>", value, "确认时间");
            return (Criteria) this;
        }

        public Criteria and确认时间GreaterThan(Date value) {
            addCriterion("确认时间 >", value, "确认时间");
            return (Criteria) this;
        }

        public Criteria and确认时间GreaterThanOrEqualTo(Date value) {
            addCriterion("确认时间 >=", value, "确认时间");
            return (Criteria) this;
        }

        public Criteria and确认时间LessThan(Date value) {
            addCriterion("确认时间 <", value, "确认时间");
            return (Criteria) this;
        }

        public Criteria and确认时间LessThanOrEqualTo(Date value) {
            addCriterion("确认时间 <=", value, "确认时间");
            return (Criteria) this;
        }

        public Criteria and确认时间In(List<Date> values) {
            addCriterion("确认时间 in", values, "确认时间");
            return (Criteria) this;
        }

        public Criteria and确认时间NotIn(List<Date> values) {
            addCriterion("确认时间 not in", values, "确认时间");
            return (Criteria) this;
        }

        public Criteria and确认时间Between(Date value1, Date value2) {
            addCriterion("确认时间 between", value1, value2, "确认时间");
            return (Criteria) this;
        }

        public Criteria and确认时间NotBetween(Date value1, Date value2) {
            addCriterion("确认时间 not between", value1, value2, "确认时间");
            return (Criteria) this;
        }
    }

    public static class Criteria extends GeneratedCriteria {
        protected Criteria() {
            super();
        }
    }

    public static class Criterion {
        private String condition;

        private Object value;

        private Object secondValue;

        private boolean noValue;

        private boolean singleValue;

        private boolean betweenValue;

        private boolean listValue;

        private String typeHandler;

        public String getCondition() {
            return condition;
        }

        public Object getValue() {
            return value;
        }

        public Object getSecondValue() {
            return secondValue;
        }

        public boolean isNoValue() {
            return noValue;
        }

        public boolean isSingleValue() {
            return singleValue;
        }

        public boolean isBetweenValue() {
            return betweenValue;
        }

        public boolean isListValue() {
            return listValue;
        }

        public String getTypeHandler() {
            return typeHandler;
        }

        protected Criterion(String condition) {
            super();
            this.condition = condition;
            this.typeHandler = null;
            this.noValue = true;
        }

        protected Criterion(String condition, Object value, String typeHandler) {
            super();
            this.condition = condition;
            this.value = value;
            this.typeHandler = typeHandler;
            if (value instanceof List<?>) {
                this.listValue = true;
            } else {
                this.singleValue = true;
            }
        }

        protected Criterion(String condition, Object value) {
            this(condition, value, null);
        }

        protected Criterion(String condition, Object value, Object secondValue, String typeHandler) {
            super();
            this.condition = condition;
            this.value = value;
            this.secondValue = secondValue;
            this.typeHandler = typeHandler;
            this.betweenValue = true;
        }

        protected Criterion(String condition, Object value, Object secondValue) {
            this(condition, value, secondValue, null);
        }
    }
}